@valbuild/core 0.143.0 → 0.145.0

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

@@ -0,0 +1,63 @@
+import { filedir } from "./filedir.js";
+import type { MediaDir } from "./record.js";
+/**
+ * Options for `s.fontdir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+export type FontdirOptions = {
+    /**
+     * The accepted font types. Defaults to every web font format:
+     * `"font/woff2,font/woff,font/ttf,font/otf"`. Narrow it to `"font/woff2"` to
+     * keep the site's fonts to the one format every current browser reads and
+     * that is smallest on the wire.
+     */
+    accept?: string;
+};
+/**
+ * Options for the deprecated `s.fontset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.fontdir(dir, options)` and `FontdirOptions`.
+ */
+export type FontsetOptions = FontdirOptions & {
+    /**
+     * The directory where fonts should be stored.
+     * Must start with "/public" (e.g., "/public/val/fonts")
+     */
+    dir: MediaDir;
+};
+/**
+ * Define a directory of fonts.
+ *
+ * A fontdir IS a filedir — the same source, the same `s.font(fontsVal)` field
+ * to pick from it, the same checks and fixes — with `accept` defaulting to the
+ * web font formats. What a font gets that any other file does not is decided
+ * by its mime type rather than by the directory: the Studio previews any file
+ * it knows is a font, wherever it is shown.
+ *
+ * Remote is off by default: call `.remote()` on the result to allow remote files.
+ *
+ * @example
+ * ```typescript
+ * const schema = s.fontdir("/public/val/fonts");
+ * export default c.define("/content/fonts.val.ts", schema, {
+ *   "/public/val/fonts/inter_a1b2c.woff2": {
+ *     mimeType: "font/woff2",
+ *   },
+ * });
+ * ```
+ */
+export declare const fontdir: (dir: MediaDir, options?: FontdirOptions) => ReturnType<typeof filedir>;
+/**
+ * Define a collection of fonts.
+ *
+ * @deprecated Use `s.fontdir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.fontset({ dir: "/public/val/fonts" })
+ * const schema = s.fontdir("/public/val/fonts");
+ * ```
+ */
+export declare const fontset: (options: FontsetOptions) => ReturnType<typeof filedir>;

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

@@ -5,7 +5,7 @@ import type { SerializedSchema } from "./index.js";
  * The one answer to that question. There used to be two — `hasRemoteFileSchema`
  * in the server, gating whether `/save` demands remote credentials, and
  * `findRequiredRemoteFiles` in the Studio, gating the `/remote/settings` fetch —
- * and they disagreed about `s.imageset({ ... }).remote()`: the Studio's version
+ * and they disagreed about `s.imagedir(dir, { ... }).remote()`: the Studio's version
  * counted a remote media record, the server's did not, because a media
  * collection serializes as a `record` of metadata rather than as an image
  * schema.
@@ -43,8 +43,8 @@ export declare function hasRemoteFileSchema(schema: SerializedSchema): boolean;
  *
  * It is a walk over the SERIALIZED schema for the reasons given above, and for
  * one more that is specific to this question: the two cases most likely to be
- * missed are invisible to a value type. A media collection (`s.imageset()` /
- * `s.fileset()`) serializes as a record of metadata with no image schema inside
+ * missed are invisible to a value type. A media collection (`s.imagedir()` /
+ * `s.filedir()`) serializes as a record of metadata with no image schema inside
  * it, and a richtext inline image lives in a constructor argument. A check
  * written against the item TYPE would silently pass both — and the gallery case
  * already has a data-loss incident attached to it (see above).

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

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

package/dist/declarations/src/schema/{imageset.d.ts → imagedir.d.ts}

@@ -1,6 +1,6 @@
 import { Schema } from "./index.js";
 import type { SelectorOfSchema } from "./index.js";
-import type { SerializedRecordSchema } from "./record.js";
+import type { MediaDir, SerializedRecordSchema } from "./record.js";
 import { RecordSchema } from "./record.js";
 import { ObjectSchema } from "./object.js";
 import { StringSchema } from "./string.js";
@@ -22,18 +22,32 @@ export type AltSourceOf<Alt extends AltSchema> = SelectorOfSchema<Alt>;
 /** Every `alt` value any `AltSchema` can produce. */
 export type AltSource = AltSourceOf<AltSchema>;
 /**
- * Options for s.imageset()
+ * Options for `s.imagedir(dir, options)`: everything but the directory, which
+ * is the first argument.
  */
-export type ImagesetOptions<Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>> = ImagesetOptionsBase<Accept> & ImagesetAltOption<Alt>;
+export type ImagedirOptions<Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>> = ImagedirOptionsBase<Accept> & ImagedirAltOption<Alt>;
+/**
+ * Options for the deprecated `s.imageset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.imagedir(dir, options)` and `ImagedirOptions`.
+ */
+export type ImagesetOptions<Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>> = ImagedirOptions<Accept, Alt> & {
+    /**
+     * The directory where images should be stored.
+     * Must start with "/public" (e.g., "/public/val/images")
+     */
+    dir: MediaDir;
+};
 /**
  * `alt` is optional only when it is the default schema.
  *
  * Naming a different `Alt` and then leaving `alt` out would make the fallback
- * in `imageset()` a lie — `Alt` would say `s.string()` while the value was a
+ * in `imagedir()` a lie — `Alt` would say `s.string()` while the value was a
  * nullable one. Requiring it in that case is what makes the fallback sound:
  * the branch that uses it is reachable only when `Alt` IS the default.
  */
-type ImagesetAltOption<Alt extends AltSchema> = [
+type ImagedirAltOption<Alt extends AltSchema> = [
     StringSchema<string | null>
 ] extends [Alt] ? {
     /**
@@ -47,27 +61,23 @@ type ImagesetAltOption<Alt extends AltSchema> = [
     /** Alt text schema — required, because it is not the default one. */
     alt: Alt;
 };
-type ImagesetOptionsBase<Accept extends `image/${string}`> = {
+/**
+ * The options argument of `s.imagedir()`: optional only when `alt` is, for
+ * the reason `ImagedirAltOption` gives — leaving the whole object out leaves
+ * `alt` out with it.
+ */
+type ImagedirOptionsArg<Accept extends `image/${string}`, Alt extends AltSchema> = [StringSchema<string | null>] extends [Alt] ? [options?: ImagedirOptions<Accept, Alt>] : [options: ImagedirOptions<Accept, Alt>];
+type ImagedirOptionsBase<Accept extends `image/${string}`> = {
     /**
      * The accepted mime type pattern. Must be an image type (e.g., "image/png", "image/webp", "image/*")
      * @default "image/*"
      */
     accept?: Accept;
-    /**
-     * The directory where images should be stored.
-     * Must start with "/public" (e.g., "/public/val/images")
-     *
-     * Required, and deliberately so: it decides where every uploaded file in this
-     * collection lands, and it used to default to "/public/val" — which meant a
-     * gallery that had simply not said where it wanted its files silently shared a
-     * directory with every other one.
-     */
-    dir: "/public" | `/public/${string}`;
     /**
      * Re-encode uploads in the browser before they are uploaded.
      *
      * Off unless set. A field backed by this gallery (`s.image(galleryVal)`)
-     * inherits it, the same way it inherits `accept` and `directory`.
+     * inherits it, the same way it inherits `accept` and the directory.
      */
     encode?: ImageEncodeOption;
 };
@@ -76,10 +86,10 @@ type ImagesetOptionsBase<Accept extends `image/${string}`> = {
  *
  * `alt` follows the schema's `alt` option, so it defaults to `string | null`
  * and becomes `string` under `s.string()` or `Record<string, string>` under
- * `s.record(s.string())`. Write `ImagesetEntryMetadata<AltSource>` where a
+ * `s.record(s.string())`. Write `ImagedirEntryMetadata<AltSource>` where a
  * gallery of any alt shape is acceptable.
  */
-export type ImagesetEntryMetadata<Alt extends AltSource = string | null> = {
+export type ImagedirEntryMetadata<Alt extends AltSource = string | null> = {
     width: number;
     height: number;
     mimeType: string;
@@ -89,31 +99,37 @@ export type ImagesetEntryMetadata<Alt extends AltSource = string | null> = {
         y: number;
     };
 };
-export type SerializedImagesetSchema = SerializedRecordSchema;
-type ImagesetItemProps<Alt extends AltSchema> = {
+/** @deprecated Use `ImagedirEntryMetadata`. */
+export type ImagesetEntryMetadata<Alt extends AltSource = string | null> = ImagedirEntryMetadata<Alt>;
+export type SerializedImagedirSchema = SerializedRecordSchema;
+/** @deprecated Use `SerializedImagedirSchema`. */
+export type SerializedImagesetSchema = SerializedImagedirSchema;
+type ImagedirItemProps<Alt extends AltSchema> = {
     width: NumberSchema<number>;
     height: NumberSchema<number>;
     mimeType: StringSchema<string>;
     alt: Alt;
 };
-type ImagesetItemSrc<Alt extends AltSchema> = {
+type ImagedirItemSrc<Alt extends AltSchema> = {
     width: number;
     height: number;
     mimeType: string;
     alt: AltSourceOf<Alt>;
 };
+type ImagedirSchema<Alt extends AltSchema> = RecordSchema<ObjectSchema<ImagedirItemProps<Alt>, ImagedirItemSrc<Alt>>, Schema<string>, Record<string, ImagedirEntryMetadata<AltSourceOf<Alt>>>>;
 /**
- * Define a collection of images.
+ * Define a directory of images: a whole module that holds many images, keyed
+ * by their file path, that fields pick from with `s.image(galleryVal)`.
  *
- * `directory` is required — it decides where uploads land, so it is not something
- * to be inferred. The rest defaults: any image type (`"image/*"`), nullable alt
- * text, remote disabled. Call `.remote()` on the result to allow remote images.
+ * The directory is the first argument and is required — it decides where
+ * uploads land, so it is not something to be inferred. The rest defaults: any
+ * image type (`"image/*"`), nullable alt text, remote disabled. Call
+ * `.remote()` on the result to allow remote images.
  *
  * @example
  * ```typescript
- * const schema = s.imageset({
+ * const schema = s.imagedir("/public/val/images", {
  *   accept: "image/webp",
- *   dir: "/public/val/images",
  *   alt: s.string().minLength(4),
  * });
  * export default c.define("/content/images.val.ts", schema, {
@@ -126,5 +142,23 @@ type ImagesetItemSrc<Alt extends AltSchema> = {
  * });
  * ```
  */
-export declare const imageset: <Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>>(options: ImagesetOptions<Accept, Alt>) => RecordSchema<ObjectSchema<ImagesetItemProps<Alt>, ImagesetItemSrc<Alt>>, Schema<string>, Record<string, ImagesetEntryMetadata<AltSourceOf<Alt>>>>;
+export declare const imagedir: <Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>>(dir: MediaDir, ...[options]: ImagedirOptionsArg<Accept, Alt>) => ImagedirSchema<Alt>;
+/**
+ * `s.imagedir()` with `.remote()` applied: what `s.imagedir` is under
+ * `files: { remote: true }`.
+ */
+export declare const remoteImagedir: <Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>>(dir: MediaDir, ...[options]: ImagedirOptionsArg<Accept, Alt>) => ImagedirSchema<Alt>;
+/**
+ * Define a collection of images.
+ *
+ * @deprecated Use `s.imagedir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.imageset({ dir: "/public/val/images", accept: "image/webp" })
+ * const schema = s.imagedir("/public/val/images", { accept: "image/webp" });
+ * ```
+ */
+export declare const imageset: <Accept extends `image/${string}`, Alt extends AltSchema = StringSchema<string | null>>(options: ImagesetOptions<Accept, Alt>) => ImagedirSchema<Alt>;
 export {};

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

@@ -1,16 +1,23 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
+import { NumberRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
-type NumberOptions = {
-    max?: number;
-    min?: number;
-};
+import { NumberRules } from "./numberRules.js";
+/**
+ * What the value has to be. `integer` is what makes a number schema an
+ * `s.int()`: the source is a number either way, so an int is a number schema
+ * with one more rule rather than a schema type of its own (which every walk
+ * over a schema would have had to learn).
+ */
+type NumberOptions = NumberRules;
 export type SerializedNumberSchema = {
     type: "number";
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     options?: NumberOptions;
+    /** How the field is edited. Static config — see `render.ts`. */
+    render?: NumberRender;
     opt: boolean;
     customValidate?: boolean;
     readonly?: boolean;
@@ -25,7 +32,8 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
-    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    private readonly renderInput;
+    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, renderInput?: NumberRender | null);
     /**
      * Describe this field.
      *
@@ -86,6 +94,37 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
      * export default c.define("/example.val.ts", schema, 3);
      */
     min(min: number): NumberSchema<Src>;
+    /**
+     * Validate that the number is on a grid of `step`: one of `min`, `min + step`,
+     * `min + 2 * step` and so on, counted from 0 when there is no `.min()`.
+     *
+     * A slider rendered on this field moves in the same steps unless its render
+     * says otherwise (and then its step has to be a multiple of this one).
+     *
+     * @example
+     * const schema = s.int().min(0).max(100).step(5);
+     * export default c.define("/example.val.ts", schema, 40);
+     */
+    step(step: number): NumberSchema<Src>;
+    /**
+     * Choose how this field is edited. `{ as: "slider", min, max }` edits it with
+     * a slider from `min` to `max`, next to a box for typing an exact value.
+     *
+     * `min` and `max` are required — a slider without ends is not a slider — and
+     * they are the slider's, not validation: use `.min()` / `.max()` for what the
+     * value may be. The slider can only produce values this schema accepts, so
+     * its range must lie inside `.min()`/`.max()`, its `step` (which defaults to
+     * `.step()`, then 1) must be a multiple of `.step()`, and on `s.int()` all of
+     * them must be whole numbers. A schema that breaks this throws here.
+     *
+     * Static configuration, not a callback — see `render.ts`. A second
+     * `.render(...)` replaces the first.
+     *
+     * @example
+     * const schema = s.int().render({ as: "slider", min: 0, max: 100, step: 5 });
+     * export default c.define("/example.val.ts", schema, 40);
+     */
+    render(input: NumberRender): NumberSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a
@@ -104,4 +143,5 @@ export declare class NumberSchema<Src extends number | null> extends Schema<Src>
     protected executeSerialize(): SerializedSchema;
 }
 export declare const number: (options?: NumberOptions) => NumberSchema<number>;
+export declare const int: () => NumberSchema<number>;
 export {};

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

@@ -0,0 +1,27 @@
+/**
+ * What a number schema accepts, in one place, so the validator and the
+ * Studio's "Round to …" / "Set to …" buttons cannot disagree about it.
+ *
+ * A button that offers a value the validator then rejects is worse than no
+ * button, which is exactly what two copies of this arithmetic would drift into.
+ */
+export type NumberRules = {
+    min?: number;
+    max?: number;
+    /** Whole numbers only — `s.int()`. */
+    integer?: boolean;
+    /** Allowed values are `origin + n * step`, where the origin is `min` or 0. */
+    step?: number;
+};
+/** Where the step grid starts: the schema's `min`, or 0 when it has none. */
+export declare function stepOrigin(rules: NumberRules): number;
+/** Is `value` one of `origin + n * step`? */
+export declare function isOnStep(value: number, origin: number, step: number): boolean;
+/**
+ * The allowed value closest to `value`: inside `min`/`max`, on the step grid,
+ * and whole when the schema is an int.
+ *
+ * Returns `null` when the rules leave nothing to snap to — a `min` above
+ * `max`, or a range too narrow to hold a single step or a single whole number.
+ */
+export declare function nearestAllowedNumber(value: number, rules: NumberRules): number | null;

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

@@ -20,8 +20,19 @@ type MediaOptions = {
     /** Videos only: whether uploads become HLS streams. See `video.ts`. */
     stream?: VideoStreamOption;
 };
-/** What a media collection (`s.imageset`, `s.fileset`, `s.videoset`) holds. */
+/** What a media collection (`s.imagedir`, `s.filedir`, `s.videodir`) holds. */
 export type MediaCollectionType = "files" | "images" | "videos";
+/**
+ * Where a media collection keeps its files: the first argument of
+ * `s.imagedir()`, `s.filedir()`, `s.fontdir()` and `s.videodir()`.
+ *
+ * Required, and deliberately so: it decides where every uploaded file in the
+ * collection lands. It used to default to "/public/val", which meant a
+ * collection that had simply not said where it wanted its files silently
+ * shared a directory with every other one. It is the first argument rather
+ * than an option because it is the one thing every collection has to say.
+ */
+export type MediaDir = "/public" | `/public/${string}`;
 export type SerializedRecordSchema = {
     type: "record";
     item: SerializedSchema;
@@ -258,7 +269,7 @@ RO extends boolean = false> extends Schema<Src> {
      * Allow the files in this gallery to be stored on Val's remote content host
      * instead of in your repository.
      *
-     * For `s.imageset()` and `s.fileset()`, which are records of media. Remote is off
+     * For `s.imagedir()` and `s.filedir()`, which are records of media. Remote is off
      * until this is called.
      *
      * Each entry is then keyed by its URL on the content host rather than by a
@@ -267,7 +278,7 @@ RO extends boolean = false> extends Schema<Src> {
      * upload it and rewrite the key.
      *
      * @example
-     * const schema = s.imageset({ dir: "/public/val/images" }).remote();
+     * const schema = s.imagedir("/public/val/images").remote();
      * export default c.define("/content/images.val.ts", schema, {
      *   "https://remote.val.build/file/p/my-project/b/01/v/1.0.0/h/8f2a1c/f/3b9d70/p/public/val/images/hero.webp":
      *     {
@@ -286,7 +297,7 @@ RO extends boolean = false> extends Schema<Src> {
      * which lets the runtime, the Studio and validation work one entry at a time
      * so a record/router can scale to many thousands of entries.
      *
-     * Not supported on image/file galleries (`s.imageset()` / `s.fileset()`).
+     * Not supported on image/file galleries (`s.imagedir()` / `s.filedir()`).
      *
      * Only supported on a module's ROOT record/router — a `.jsonValues()` record
      * nested inside an object/array/record is rejected at startup with a module
@@ -313,7 +324,7 @@ RO extends boolean = false> extends Schema<Src> {
      * bucket — instead of in the module.
      *
      * Available on every record-derived schema, which is `s.record()`,
-     * `s.router()`, `s.imageset()` and `s.fileset()` alike: a router is a
+     * `s.router()`, `s.imagedir()` and `s.filedir()` alike: a router is a
      * `RecordSchema` with a `ValRouter`, a gallery one with media options, so all
      * four get external storage from this one method.
      *
@@ -396,7 +407,7 @@ RO extends boolean = false> extends Schema<Src> {
      * draws each entry's own editor in place, labelled by its key, instead of a
      * preview row that navigates to it. It reaches the direct entries only.
      *
-     * Not for `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`: pages and
+     * Not for `s.router(...)`, `s.imagedir(...)` or `s.filedir(...)`: pages and
      * media have UIs of their own, so this throws on them.
      *
      * Static configuration, not a callback — see `render.ts`.

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

@@ -2,8 +2,8 @@ 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 type { AltSource } from "./imagedir.js";
+import type { VideodirEntryMetadata } from "./videodir.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import { ItemPreviewInput, PreviewItem } from "../preview.js";
 import { FieldRender } from "../render.js";
@@ -67,7 +67,7 @@ export type VideoGallery = {
      * 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;
+    entries: Record<string, VideodirEntryMetadata<AltSource>> | null;
     remote: boolean;
 };
 export type SerializedVideoSchema = {
@@ -80,7 +80,7 @@ export type SerializedVideoSchema = {
     opt: boolean;
     remote?: boolean;
     customValidate?: boolean;
-    /** The `s.videoset()` module this field picks from, if it is set-backed. */
+    /** The `s.videodir()` module this field picks from, if it is set-backed. */
     referencedModule?: string;
     readonly?: boolean;
     hidden?: boolean;
@@ -230,11 +230,11 @@ export declare class VideoSchema<Src extends GalleryVideoSource | null> extends
  */
 export declare function filesOfVideoSource(src: GalleryVideoSource): string[];
 /**
- * A video picked from a set (`s.videoset()`). What is true of the file —
+ * A video picked from a set (`s.videodir()`). 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>;
+export declare function video(videosetModule: ValModule<Record<string, VideodirEntryMetadata<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.
@@ -245,5 +245,5 @@ export declare function video(options?: VideoOptions): VideoSchema<VideoSource>;
  * `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(videosetModule: ValModule<Record<string, VideodirEntryMetadata<AltSource>>>, galleryOptions?: GalleryVideoOptions): VideoSchema<GalleryVideoSource>;
 export declare function remoteVideo(options?: VideoOptions): VideoSchema<VideoSource>;