@valbuild/core 0.143.0 → 0.145.0

package/dist/{index-46c72f01.cjs.prod.js → index-93763025.cjs.prod.js}

@@ -2846,7 +2846,7 @@ var _excluded = ["poster", "captions"];
  * What a video FIELD authors, on top of the file it names: the description,
  * the crop, the poster, the trim and the caption tracks.
  *
- * This is the whole value of a field picked from an `s.videoset()`
+ * This is the whole value of a field picked from an `s.videodir()`
  * (`s.video(videosetVal)`) — the mime type, size and length live in the set,
  * keyed by `path`, and repeating them here is how two copies of one fact get
  * to disagree. The poster, captions and times stay with the FIELD: one video
@@ -2858,7 +2858,7 @@ var _excluded = ["poster", "captions"];
 /**
  * What one page chooses about a video — as opposed to what is true of the
  * file. A field (`s.video()`) carries these for itself; the entry of a set
- * (`s.videoset()`) carries them as DEFAULTS, which every field picked from the
+ * (`s.videodir()`) carries them as DEFAULTS, which every field picked from the
  * set starts from and may override key by key. See {@link fillFromGallery}.
  */
 
@@ -3000,6 +3000,42 @@ function isMediaSchema(schema) {
   return _typeof(schema) === "object" && schema !== null && "type" in schema && (schema.type === "image" || schema.type === "file" || schema.type === "video");
 }
 
+/**
+ * The key of a gallery (an `s.imagedir()`, `s.filedir()` or `s.videodir()`)
+ * that a field's `path` names, or `null` when it names none.
+ *
+ * Usually the path IS the key. It is not for an image uploaded THROUGH an
+ * `s.image(remoteGallery)` field in the Studio, which stores the remote ref in
+ * the field and keys the entry by the local path inside it — so a path that is
+ * not a key falls back to that embedded path. Exact first, because a gallery
+ * can hold both shapes for one file, and the field then names the entry that
+ * IS its path.
+ *
+ * One implementation of the question, asked by everything that has to agree on
+ * the answer: reading a field (`galleryEntryOf`), validating it (`ImageSchema`
+ * and `FileSchema` ask whether the gallery has it), the Studio's reference
+ * scans and renames, and `val validate --fix` when it renames a key and has to
+ * find the fields that hold it.
+ *
+ * The embedded path is tried with its leading slash (how a key is written) and
+ * without (how `splitRemoteRef` returns it).
+ */
+function galleryKeyOf(path, isKey) {
+  if (isKey(path)) {
+    return path;
+  }
+  var split = splitRemoteRef(path);
+  if (split.status === "success") {
+    for (var _i = 0, _arr = ["/".concat(split.filePath), split.filePath]; _i < _arr.length; _i++) {
+      var embedded = _arr[_i];
+      if (isKey(embedded)) {
+        return embedded;
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * What a gallery entry holds as a DEFAULT for the fields picked from it, in
  * the groups a field overrides together.
@@ -3019,7 +3055,9 @@ var GALLERY_FILE_FACTS = ["width", "height", "mimeType", "duration"];
  * gallery-backed or the gallery has no such entry.
  *
  * The double lookup is load-bearing: a remote gallery keys its entries by the
- * remote URL while the file itself stays on disk under its local path.
+ * remote URL while the file itself stays on disk under its local path, and an
+ * upload through the field does it the other way round (see
+ * {@link galleryKeyOf}).
  */
 function galleryEntryOf(src, schema, getModuleSource) {
   if (!isMediaSchema(schema) || !schema.referencedModule) {
@@ -3029,13 +3067,9 @@ function galleryEntryOf(src, schema, getModuleSource) {
   if (!isPlainObject(moduleSource)) {
     return null;
   }
-  var key = src.path in moduleSource ? src.path : null;
-  if (key === null) {
-    var splitRemoteRefRes = splitRemoteRef(src.path);
-    if (splitRemoteRefRes.status === "success" && splitRemoteRefRes.filePath in moduleSource) {
-      key = splitRemoteRefRes.filePath;
-    }
-  }
+  var key = galleryKeyOf(src.path, function (candidate) {
+    return candidate in moduleSource;
+  });
   if (key === null) {
     return null;
   }
@@ -3896,10 +3930,10 @@ function mimeTypeMatchesAccept(mimeType, accept) {
  * asks the BYTES ({@link sniffFontMimeType}) rather than trusting the picker.
  */
 
-/** The formats `s.fontset()` accepts unless told otherwise, best first. */
+/** The formats `s.fontdir()` accepts unless told otherwise, best first. */
 var FONT_MIME_TYPES = ["font/woff2", "font/woff", "font/ttf", "font/otf"];
 
-/** `s.fontset()`'s `accept` when none is given. */
+/** `s.fontdir()`'s `accept` when none is given. */
 var DEFAULT_FONT_ACCEPT = FONT_MIME_TYPES.join(",");
 
 /**
@@ -4138,24 +4172,31 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]));
       }
+      // A field picked from a gallery holds the gallery's KEY, and whether that
+      // key is a local path or a remote ref is the gallery's to decide — and its
+      // to fix: uploading an entry renames its key, and the fields that hold it
+      // with it. So such a field only asks whether the gallery has it, below.
+      // Asking here as well reported every image picked from a `.remote()`
+      // gallery as one to download, because the field itself is never remote.
+      var galleryEntries = this.galleryEntries();
       // Remote-ness is a property of the path, not of a marker on the value:
       // anything outside /public is remote.
       var isRemotePath = isRemoteMediaPath(src.path);
-      if (this.isRemote && !isRemotePath) {
+      if (!galleryEntries && this.isRemote && !isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected a remote image, but got a local image.",
           value: src,
           fixes: ["image:upload-remote"]
         }]));
       }
-      if (this.isRemote && isRemotePath) {
+      if (!galleryEntries && this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Remote image was not checked.",
           value: src,
           fixes: ["image:check-remote"]
         }]));
       }
-      if (!this.isRemote && isRemotePath) {
+      if (!galleryEntries && !this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected local image, but found remote.",
           value: src,
@@ -4170,7 +4211,6 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
           }]));
         }
       }
-      var galleryEntries = this.galleryEntries();
       if (galleryEntries) {
         // The dimensions and mime type of a gallery image are stored once, in the
         // gallery. Repeating them on the field is how the two get to disagree.
@@ -4183,7 +4223,11 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
             value: src
           }]));
         }
-        if (!(src.path in galleryEntries)) {
+        // The same match reading the field makes (`fillFromGallery`): the key,
+        // or the local path inside a ref an upload through the field stored.
+        if (galleryKeyOf(src.path, function (key) {
+          return key in galleryEntries;
+        }) === null) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
             message: "The gallery does not have an image at '".concat(src.path, "'."),
             value: src
@@ -5800,7 +5844,7 @@ function missingDeclaredKeys(declared, present) {
 /**
  * The checks of what one page chose about a video — its times, focal point,
  * poster and captions — shared by the two places those choices are made: a
- * field (`s.video()`) and the entry of a set (`s.videoset()`), which holds the
+ * field (`s.video()`) and the entry of a set (`s.videodir()`), which holds the
  * same choices as the defaults every field picked from it starts from.
  */
 
@@ -5978,7 +6022,25 @@ function isObject(value) {
   return _typeof(value) === "object" && value !== null && !Array.isArray(value);
 }
 
-/** What a media collection (`s.imageset`, `s.fileset`, `s.videoset`) holds. */
+/** What a media collection (`s.imagedir`, `s.filedir`, `s.videodir`) holds. */
+
+/**
+ * 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.
+ */
+
+/** The factory that builds a media collection of each type, for messages. */
+var mediaDirFactory = {
+  images: "imagedir",
+  files: "filedir",
+  videos: "videodir"
+};
 
 /**
  * The fix code a media collection of `type` reports for `check`.
@@ -6013,7 +6075,7 @@ function assertRenderable(router, mediaOptions, render) {
     throw new Error("`.render(...)` is not supported on `s.router(...)`: a router's entries are pages, which have their own UI.");
   }
   if (mediaOptions) {
-    throw new Error("`.render(...)` is not supported on `s.".concat(mediaOptions.type === "images" ? "imageset" : "fileset", "(...)`: media galleries have their own UI."));
+    throw new Error("`.render(...)` is not supported on `s.".concat(mediaDirFactory[mediaOptions.type], "(...)`: media galleries have their own UI."));
   }
 }
 
@@ -6730,7 +6792,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * 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
@@ -6739,7 +6801,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * 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":
      *     {
@@ -6765,7 +6827,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * 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
@@ -6790,7 +6852,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     key: "jsonValues",
     value: function jsonValues() {
       if (this.mediaOptions) {
-        throw new Error(".jsonValues() cannot be used with image/file galleries (s.imageset()/s.fileset())");
+        throw new Error(".jsonValues() cannot be used with image/file galleries (s.imagedir()/s.filedir())");
       }
       if (this.customValidateFunctions.length > 0) {
         // `.jsonValues()` changes the source shape to JsonSource entries, so a
@@ -6819,7 +6881,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * 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.
      *
@@ -7149,7 +7211,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
      * 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`.
@@ -10125,6 +10187,87 @@ function patchPathToModulePath(patchPath) {
   }).join(".");
 }
 
+/**
+ * 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.
+ */
+
+/**
+ * Division of decimals is not exact (`0.3 / 0.1` is `2.9999999999999996`), so a
+ * value counts as on the grid when it is within this many steps of it.
+ */
+var GRID_EPSILON = 1e-9;
+
+/** Where the step grid starts: the schema's `min`, or 0 when it has none. */
+function stepOrigin(rules) {
+  var _rules$min;
+  return (_rules$min = rules.min) !== null && _rules$min !== void 0 ? _rules$min : 0;
+}
+
+/** Is `value` one of `origin + n * step`? */
+function isOnStep(value, origin, step) {
+  var steps = (value - origin) / step;
+  return Math.abs(steps - Math.round(steps)) < GRID_EPSILON;
+}
+
+/**
+ * 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.
+ */
+function nearestAllowedNumber(value, rules) {
+  var _rules$step;
+  var step = (_rules$step = rules.step) !== null && _rules$step !== void 0 ? _rules$step : rules.integer ? 1 : undefined;
+  var lo = rules.min;
+  var hi = rules.max;
+  if (lo !== undefined && hi !== undefined && lo > hi) {
+    return null;
+  }
+  var clamp = function clamp(n) {
+    return Math.min(hi !== null && hi !== void 0 ? hi : Infinity, Math.max(lo !== null && lo !== void 0 ? lo : -Infinity, n));
+  };
+  if (step === undefined) {
+    return clamp(value);
+  }
+  var origin = rules.integer && rules.step === undefined ? 0 : stepOrigin(rules);
+  var toGrid = function toGrid(n) {
+    return roundToDecimals(origin + n * step);
+  };
+  var n = Math.round((clamp(value) - origin) / step);
+  // Rounding can step outside the range by one; walk back in.
+  if (lo !== undefined && toGrid(n) < lo) n += 1;
+  if (hi !== undefined && toGrid(n) > hi) n -= 1;
+  var snapped = toGrid(n);
+  if (lo !== undefined && snapped < lo || hi !== undefined && snapped > hi) {
+    return null;
+  }
+  if (rules.integer && !Number.isInteger(snapped)) {
+    return null;
+  }
+  return snapped;
+}
+
+/**
+ * `0.1 + 0.2` is `0.30000000000000004`. A value offered to an editor should
+ * read `0.3`, so grid values are rounded to 12 significant decimals — far below
+ * any step anyone writes, far above floating point noise.
+ */
+function roundToDecimals(n) {
+  return Number.parseFloat(n.toFixed(12));
+}
+
+/**
+ * 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).
+ */
+
 var NumberSchema = /*#__PURE__*/function (_Schema) {
   function NumberSchema(options) {
     var _this;
@@ -10134,6 +10277,7 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
     var isHidden = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
     var description = arguments.length > 5 ? arguments[5] : undefined;
     var previewInput = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+    var renderInput = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
     _classCallCheck(this, NumberSchema);
     _this = _callSuper(this, NumberSchema);
     _this.options = options;
@@ -10143,6 +10287,8 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
     _this.isHidden = isHidden;
     _this.description = description;
     _this.previewInput = previewInput;
+    _this.renderInput = renderInput;
+    assertNumberSchemaIsConsistent(_this.options, _this.renderInput);
     return _this;
   }
 
@@ -10167,7 +10313,7 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   return _createClass(NumberSchema, [{
     key: "describe",
     value: function describe(description) {
-      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.previewInput);
+      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.previewInput, this.renderInput);
     }
 
     /**
@@ -10193,12 +10339,12 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "validate",
     value: function validate(validationFunction) {
-      return new NumberSchema(this.options, this.opt, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description, this.previewInput);
+      return new NumberSchema(this.options, this.opt, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
     }
   }, {
     key: "executeValidate",
     value: function executeValidate(path, src) {
-      var _this$options, _this$options2;
+      var _this$options;
       var customValidationErrors = this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
         path: path
       });
@@ -10211,20 +10357,35 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]));
       }
-      if ((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.max && src > this.options.max) {
-        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-          message: "Expected 'number' less than ".concat(this.options.max),
+      var errors = _toConsumableArray(customValidationErrors);
+      var options = (_this$options = this.options) !== null && _this$options !== void 0 ? _this$options : {};
+      // `!== undefined`, not truthiness: a bound of 0 is a bound. `.max(0)` and
+      // `.min(0)` used to be ignored, which a slider from 0 makes common.
+      if (options.max !== undefined && src > options.max) {
+        errors.push({
+          message: "Must be at most ".concat(options.max),
           value: src
-        }]));
+        });
       }
-      if ((_this$options2 = this.options) !== null && _this$options2 !== void 0 && _this$options2.min && src < this.options.min) {
-        return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
-          message: "Expected 'number' greater than ".concat(this.options.min),
+      if (options.min !== undefined && src < options.min) {
+        errors.push({
+          message: "Must be at least ".concat(options.min),
           value: src
-        }]));
+        });
       }
-      if (customValidationErrors.length > 0) {
-        return _defineProperty({}, path, customValidationErrors);
+      if (options.integer && !Number.isInteger(src)) {
+        errors.push({
+          message: "Must be a whole number",
+          value: src
+        });
+      } else if (options.step !== undefined && !isOnStep(src, stepOrigin(options), options.step)) {
+        errors.push({
+          message: "Must be a multiple of ".concat(options.step, ", counted from ").concat(stepOrigin(options)),
+          value: src
+        });
+      }
+      if (errors.length > 0) {
+        return _defineProperty({}, path, errors);
       }
       return false;
     }
@@ -10263,19 +10424,19 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new NumberSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      return new NumberSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
     }
   }, {
     key: "readonly",
     value: function readonly() {
       var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, isReadonly, this.isHidden, this.description, this.previewInput);
+      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
     }
   }, {
     key: "hidden",
     value: function hidden() {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.previewInput);
+      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.previewInput, this.renderInput);
     }
 
     /**
@@ -10290,7 +10451,7 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
     value: function max(_max) {
       return new NumberSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         max: _max
-      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
     }
 
     /**
@@ -10305,7 +10466,50 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
     value: function min(_min) {
       return new NumberSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
         min: _min
-      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput);
+      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
+    }
+
+    /**
+     * 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);
+     */
+  }, {
+    key: "step",
+    value: function step(_step) {
+      return new NumberSchema(_objectSpread2(_objectSpread2({}, this.options), {}, {
+        step: _step
+      }), this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
+    }
+
+    /**
+     * 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);
+     */
+  }, {
+    key: "render",
+    value: function render(input) {
+      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, input);
     }
   }, {
     key: "executeCustomValidateAt",
@@ -10329,7 +10533,7 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "preview",
     value: function preview(select) {
-      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, select);
+      return new NumberSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, select, this.renderInput);
     }
   }, {
     key: "executePreviewItem",
@@ -10349,11 +10553,12 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "executeSerialize",
     value: function executeSerialize() {
-      var _this$customValidateF;
+      var _this$renderInput, _this$customValidateF;
       return {
         type: "number",
         preview: this.previewInput ? true : undefined,
         options: this.options,
+        render: (_this$renderInput = this.renderInput) !== null && _this$renderInput !== void 0 ? _this$renderInput : undefined,
         opt: this.opt,
         customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
         readonly: this.isReadonly,
@@ -10366,6 +10571,63 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
 var number = function number(options) {
   return new NumberSchema(options);
 };
+var _int = function _int() {
+  return new NumberSchema({
+    integer: true
+  });
+};
+function assertNumberSchemaIsConsistent(options, render) {
+  var opts = options !== null && options !== void 0 ? options : {};
+  var kind = opts.integer ? "s.int()" : "s.number()";
+  if (opts.step !== undefined) {
+    if (!(opts.step > 0) || !Number.isFinite(opts.step)) {
+      throw new Error("".concat(kind, ".step(").concat(opts.step, "): the step must be above 0"));
+    }
+    if (opts.integer && !Number.isInteger(opts.step)) {
+      throw new Error("".concat(kind, ".step(").concat(opts.step, "): the step of an int must be a whole number"));
+    }
+  }
+  if (render === null) {
+    return;
+  }
+  var where = "".concat(kind, ".render({ as: \"slider\", min: ").concat(render.min, ", max: ").concat(render.max, " })");
+  if (!Number.isFinite(render.min) || !Number.isFinite(render.max)) {
+    throw new Error("".concat(where, ": the slider needs a min and a max"));
+  }
+  if (!(render.min < render.max)) {
+    throw new Error("".concat(where, ": the slider's min must be below its max"));
+  }
+  if (opts.min !== undefined && render.min < opts.min) {
+    throw new Error("".concat(where, ": the slider's min ").concat(render.min, " is below the schema's min ").concat(opts.min));
+  }
+  if (opts.max !== undefined && render.max > opts.max) {
+    throw new Error("".concat(where, ": the slider's max ").concat(render.max, " is above the schema's max ").concat(opts.max));
+  }
+  if (render.step !== undefined && !(render.step > 0)) {
+    throw new Error("".concat(where, ": the slider's step must be above 0"));
+  }
+  if (opts.integer) {
+    var sliderNumbers = [["min", render.min], ["max", render.max], ["step", render.step]];
+    for (var _i = 0, _sliderNumbers = sliderNumbers; _i < _sliderNumbers.length; _i++) {
+      var _sliderNumbers$_i = _slicedToArray(_sliderNumbers[_i], 2),
+        name = _sliderNumbers$_i[0],
+        value = _sliderNumbers$_i[1];
+      if (value !== undefined && !Number.isInteger(value)) {
+        throw new Error("".concat(where, ": the slider's ").concat(name, " ").concat(value, " must be a whole number on an int"));
+      }
+    }
+  }
+  if (opts.step !== undefined) {
+    var _render$step;
+    var sliderStep = (_render$step = render.step) !== null && _render$step !== void 0 ? _render$step : opts.step;
+    if (!isOnStep(sliderStep, 0, opts.step)) {
+      throw new Error("".concat(where, ": the slider's step ").concat(sliderStep, " must be a multiple of the schema's step ").concat(opts.step));
+    }
+    if (!isOnStep(render.min, stepOrigin(opts), opts.step)) {
+      throw new Error("".concat(where, ": the slider's min ").concat(render.min, " is not one of the schema's steps (").concat(opts.step, ", counted from ").concat(stepOrigin(opts), ")"));
+    }
+  }
+}
 
 /**
  * @deprecated Use {@link SerializedDiscriminatedUnionSchema} or
@@ -10922,31 +11184,37 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
           value: src
         }]));
       }
+      // A field picked from a gallery holds the gallery's KEY, and whether that
+      // key is a local path or a remote ref is the gallery's to decide — and its
+      // to fix: uploading an entry renames its key, and the fields that hold it
+      // with it. So such a field only asks whether the gallery has it, below.
+      // Asking here as well reported every file picked from a `.remote()`
+      // gallery as one to download, because the field itself is never remote.
+      var galleryEntries = this.galleryEntries();
       // Remote-ness is a property of the path, not of a marker on the value:
       // anything outside /public is remote.
       var isRemotePath = isRemoteMediaPath(src.path);
-      if (this.isRemote && !isRemotePath) {
+      if (!galleryEntries && this.isRemote && !isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected a remote file, but got a local file.",
           value: src,
           fixes: ["file:upload-remote"]
         }]));
       }
-      if (this.isRemote && isRemotePath) {
+      if (!galleryEntries && this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Remote file was not checked.",
           value: src,
           fixes: ["file:check-remote"]
         }]));
       }
-      if (!this.isRemote && isRemotePath) {
+      if (!galleryEntries && !this.isRemote && isRemotePath) {
         return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
           message: "Expected local file, but found remote.",
           value: src,
           fixes: ["file:download-remote"]
         }]));
       }
-      var galleryEntries = this.galleryEntries();
       if (galleryEntries) {
         if (src.mimeType !== undefined) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
@@ -10954,7 +11222,11 @@ var FileSchema = /*#__PURE__*/function (_Schema) {
             value: src
           }]));
         }
-        if (!(src.path in galleryEntries)) {
+        // The same match reading the field makes (`fillFromGallery`): the key,
+        // or the local path inside a ref an upload through the field stored.
+        if (galleryKeyOf(src.path, function (key) {
+          return key in galleryEntries;
+        }) === null) {
           return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
             message: "The gallery does not have a file at '".concat(src.path, "'."),
             value: src
@@ -11190,7 +11462,7 @@ function fileOf(remote, options) {
 }
 
 /**
- * A font picked from an `s.fontset()`.
+ * A font picked from an `s.fontdir()`.
  *
  * The same field `s.file(fontsVal)` is — it stores `{ path }` and serializes
  * identically — with one thing more: it refuses a set that is not a font set,
@@ -11217,7 +11489,7 @@ function assertFontset(fontsetModule) {
     return isFontMimeType(type.trim());
   });
   if (!isFontset) {
-    throw new Error("s.font(".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "?", "): the module must be an s.fontset(). Use s.file() to pick from a set of other files."));
+    throw new Error("s.font(".concat(modulePath !== null && modulePath !== void 0 ? modulePath : "?", "): the module must be an s.fontdir(). Use s.file() to pick from a set of other files."));
   }
 }
 
@@ -11756,7 +12028,7 @@ function stripQuery(path) {
 }
 
 /**
- * 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.
  */
@@ -11791,7 +12063,7 @@ function videoOf(options, galleryOptions) {
   var setSchema = (_options$GetSchema = options[GetSchema]) === null || _options$GetSchema === void 0 ? void 0 : _options$GetSchema["executeSerialize"]();
   if ((setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) !== "record" || setSchema.mediaType !== "videos") {
     var _setSchema$mediaType, _setSchema$type;
-    throw new Error("s.video(".concat(modulePath, "): the module must be an s.videoset(). Got ").concat((setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) === "record" ? "a record of ".concat((_setSchema$mediaType = setSchema.mediaType) !== null && _setSchema$mediaType !== void 0 ? _setSchema$mediaType : "values") : (_setSchema$type = setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) !== null && _setSchema$type !== void 0 ? _setSchema$type : "no schema", "."));
+    throw new Error("s.video(".concat(modulePath, "): the module must be an s.videodir(). Got ").concat((setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) === "record" ? "a record of ".concat((_setSchema$mediaType = setSchema.mediaType) !== null && _setSchema$mediaType !== void 0 ? _setSchema$mediaType : "values") : (_setSchema$type = setSchema === null || setSchema === void 0 ? void 0 : setSchema.type) !== null && _setSchema$type !== void 0 ? _setSchema$type : "no schema", "."));
   }
   return new VideoSchema((galleryOptions === null || galleryOptions === void 0 ? void 0 : galleryOptions.stream) !== undefined ? {
     stream: galleryOptions.stream
@@ -11806,23 +12078,37 @@ function isVideosetModule(value) {
 }
 
 /**
- * Options for s.fileset()
+ * Options for `s.filedir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.fileset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.filedir(dir, options)` and `FiledirOptions`.
  */
 
 /**
  * Metadata for a file entry in the files record
  */
 
+/** @deprecated Use `FiledirEntryMetadata`. */
+
+/** @deprecated Use `SerializedFiledirSchema`. */
+
 /**
- * Define a collection of files.
+ * Define a directory of files: a whole module that holds many files, keyed by
+ * their file path, that fields pick from with `s.file(filesVal)`.
  *
- * Remote is off by default: call `.remote()` on the result to allow remote files.
+ * The directory is the first argument and is required — it decides where
+ * uploads land. Remote is off by default: call `.remote()` on the result to
+ * allow remote files.
  *
  * @example
  * ```typescript
- * const schema = s.fileset({
+ * const schema = s.filedir("/public/val/documents", {
  *   accept: "application/pdf",
- *   dir: "/public/val/documents",
  * });
  * export default c.define("/content/documents.val.ts", schema, {
  *   "/public/val/documents/report.pdf": {
@@ -11831,8 +12117,7 @@ function isVideosetModule(value) {
  * });
  * ```
  */
-var fileset = function fileset(options) {
-  var dir = options.dir;
+var filedir = function filedir(dir, options) {
   var itemSchema = new ObjectSchema({
     mimeType: new StringSchema({}, false)
   }, false);
@@ -11845,23 +12130,49 @@ var fileset = function fileset(options) {
 };
 
 /**
- * Options for s.fontset()
+ * Define a collection of files.
+ *
+ * @deprecated Use `s.filedir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.fileset({ dir: "/public/val/documents", accept: "application/pdf" })
+ * const schema = s.filedir("/public/val/documents", {
+ *   accept: "application/pdf",
+ * });
+ * ```
+ */
+var fileset = function fileset(options) {
+  return filedir(options.dir, options);
+};
+
+/**
+ * Options for `s.fontdir(dir, options)`: everything but the directory, which
+ * is the first argument.
  */
 
 /**
- * Define a collection of fonts.
+ * Options for the deprecated `s.fontset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.fontdir(dir, options)` and `FontdirOptions`.
+ */
+
+/**
+ * Define a directory of fonts.
  *
- * A fontset IS a fileset — the same source, the same `s.file(fontsVal)` field
+ * 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 set: the Studio previews any file it
- * knows is a font, wherever it is shown.
+ * 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.fontset({ dir: "/public/val/fonts" });
+ * const schema = s.fontdir("/public/val/fonts");
  * export default c.define("/content/fonts.val.ts", schema, {
  *   "/public/val/fonts/inter_a1b2c.woff2": {
  *     mimeType: "font/woff2",
@@ -11869,25 +12180,40 @@ var fileset = function fileset(options) {
  * });
  * ```
  */
-var fontset = function fontset(options) {
+var fontdir = function fontdir(dir, options) {
   var _options$accept;
-  var accept = (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_FONT_ACCEPT;
+  var accept = (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_FONT_ACCEPT;
   var notFonts = accept.split(",").map(function (type) {
     return type.trim();
   }).filter(function (type) {
     return !isFontMimeType(type);
   });
   if (notFonts.length > 0) {
-    // A fontset that took a PDF would be a fileset under a name that says
+    // A fontdir that took a PDF would be a filedir under a name that says
     // otherwise, and the Studio would draw a specimen of nothing.
-    throw new Error("s.fontset(): 'accept' may only name font types (font/woff2, font/woff, font/ttf, font/otf or font/*). Got: ".concat(notFonts.join(", "), ". Use s.fileset() for other files."));
+    throw new Error("s.fontdir(): 'accept' may only name font types (font/woff2, font/woff, font/ttf, font/otf or font/*). Got: ".concat(notFonts.join(", "), ". Use s.filedir() for other files."));
   }
-  return fileset({
-    dir: options.dir,
+  return filedir(dir, {
     accept: accept
   });
 };
 
+/**
+ * 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");
+ * ```
+ */
+var fontset = function fontset(options) {
+  return fontdir(options.dir, options);
+};
+
 var DateSchema = /*#__PURE__*/function (_Schema) {
   function DateSchema(options) {
     var _this;
@@ -12754,39 +13080,58 @@ function router(router, keyOrItem, maybeItem) {
 /** Every `alt` value any `AltSchema` can produce. */
 
 /**
- * Options for s.imageset()
+ * Options for `s.imagedir(dir, options)`: everything but the directory, which
+ * is the first argument.
+ */
+
+/**
+ * Options for the deprecated `s.imageset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.imagedir(dir, options)` and `ImagedirOptions`.
  */
 
 /**
  * `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.
  */
 
+/**
+ * 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.
+ */
+
 /**
  * Metadata for an image entry in the images record.
  *
  * `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.
  */
 
+/** @deprecated Use `ImagedirEntryMetadata`. */
+
+/** @deprecated Use `SerializedImagedirSchema`. */
+
 /**
- * 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, {
@@ -12799,19 +13144,26 @@ function router(router, keyOrItem, maybeItem) {
  * });
  * ```
  */
-var imageset = function imageset(options) {
+var imagedir = function imagedir(dir) {
+  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    _ref[_key - 1] = arguments[_key];
+  }
+  var options = _ref[0];
+  return imagedirOf(dir, options);
+};
+function imagedirOf(dir, options) {
   var _options$alt, _options$accept;
-  var dir = options.dir;
-  // `options.alt` is `Alt | undefined`, and the fallback is exactly the schema
+  // `options?.alt` is `Alt | undefined`, and the fallback is exactly the schema
   // `Alt` defaults to when `alt` is omitted. TypeScript will not narrow a type
   // parameter from the absence of a value, so it cannot see that the two agree,
   // and the fallback is asserted here.
   //
-  // Sound, not merely convenient: `ImagesetAltOption` makes `alt` REQUIRED
-  // unless `Alt` is the default, so this branch is unreachable for any other
+  // Sound, not merely convenient: `ImagedirAltOption` makes `alt` REQUIRED
+  // unless `Alt` is the default, and `ImagedirOptionsArg` makes the options
+  // object required with it, so this branch is unreachable for any other
   // `Alt`. The one assertion in this file, and it replaces the wider one that
   // used to sit on the ObjectSchema below.
-  var altSchema = (_options$alt = options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
+  var altSchema = (_options$alt = options === null || options === void 0 ? void 0 : options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
   var itemSchema = new ObjectSchema({
     width: new NumberSchema(undefined, false),
     height: new NumberSchema(undefined, false),
@@ -12820,19 +13172,57 @@ var imageset = function imageset(options) {
   }, false);
   return new RecordSchema(itemSchema, false, [], null, null, {
     type: "images",
-    accept: (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
+    accept: (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
     dir: dir,
     remote: false,
     altSchema: altSchema,
-    encode: options.encode
+    encode: options === null || options === void 0 ? void 0 : options.encode
   });
+}
+
+/**
+ * `s.imagedir()` with `.remote()` applied: what `s.imagedir` is under
+ * `files: { remote: true }`.
+ */
+var remoteImagedir = function remoteImagedir(dir) {
+  for (var _len2 = arguments.length, _ref2 = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    _ref2[_key2 - 1] = arguments[_key2];
+  }
+  var options = _ref2[0];
+  return imagedirOf(dir, options).remote();
+};
+
+/**
+ * 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" });
+ * ```
+ */
+var imageset = function imageset(options) {
+  return imagedirOf(options.dir, options);
 };
 
 /**
- * Options for s.videoset()
+ * Options for `s.videodir(dir, options)`: everything but the directory, which
+ * is the first argument.
  */
 
-/** See `ImagesetAltOption`: `alt` is optional only when it is the default. */
+/**
+ * Options for the deprecated `s.videoset(options)`, which took the directory
+ * as `dir`.
+ *
+ * @deprecated Use `s.videodir(dir, options)` and `VideodirOptions`.
+ */
+
+/** See `ImagedirAltOption`: `alt` is optional only when it is the default. */
+
+/** See `ImagedirOptionsArg`: the options are optional only when `alt` is. */
 
 /**
  * One video of a set, keyed by its file path (an HLS stream by its master
@@ -12850,19 +13240,22 @@ var imageset = function imageset(options) {
  * still for the gallery, because two stills of one video would disagree.
  */
 
+/** @deprecated Use `VideodirEntryMetadata`. */
+
+/** @deprecated Use `SerializedVideodirSchema`. */
+
 /**
- * Define a collection of videos — the video twin of `s.imageset()`.
+ * Define a directory of videos — the video twin of `s.imagedir()`.
  *
  * 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.
+ * field adds to the directory. Call `.remote()` on the result to store the
+ * videos on Val Remote.
  *
  * @example
  * ```typescript
- * const schema = s.videoset({
- *   dir: "/public/val/videos",
+ * const schema = s.videodir("/public/val/videos", {
  *   stream: { type: "hls" },
  * });
  * export default c.define("/content/videos.val.ts", schema, {
@@ -12877,11 +13270,46 @@ var imageset = function imageset(options) {
  * });
  * ```
  */
+var videodir = function videodir(dir) {
+  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    _ref[_key - 1] = arguments[_key];
+  }
+  var options = _ref[0];
+  return videodirOf(dir, options);
+};
+
+/**
+ * `s.videodir()` with `.remote()` applied: what `s.videodir` is under
+ * `files: { remote: true }`.
+ */
+var remoteVideodir = function remoteVideodir(dir) {
+  for (var _len2 = arguments.length, _ref2 = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    _ref2[_key2 - 1] = arguments[_key2];
+  }
+  var options = _ref2[0];
+  return videodirOf(dir, options).remote();
+};
+
+/**
+ * Define a collection of videos.
+ *
+ * @deprecated Use `s.videodir(dir, options)`: the directory moved out of the
+ * options and into the first argument, and nothing else changed.
+ *
+ * @example
+ * ```typescript
+ * // was: s.videoset({ dir: "/public/val/videos", stream: { type: "hls" } })
+ * const schema = s.videodir("/public/val/videos", { stream: { type: "hls" } });
+ * ```
+ */
 var videoset = function videoset(options) {
+  return videodirOf(options.dir, options);
+};
+function videodirOf(dir, options) {
   var _options$alt, _options$accept;
-  // The same assertion as in `imageset()`, and sound for the same reason:
-  // `VideosetAltOption` makes `alt` required unless `Alt` is the default.
-  var altSchema = (_options$alt = options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
+  // The same assertion as in `imagedir()`, and sound for the same reason:
+  // `VideodirAltOption` makes `alt` required unless `Alt` is the default.
+  var altSchema = (_options$alt = options === null || options === void 0 ? void 0 : options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
   var itemSchema = new ObjectSchema({
     mimeType: new StringSchema({}, false),
     width: new NumberSchema(undefined, false),
@@ -12891,13 +13319,13 @@ var videoset = function videoset(options) {
   }, false);
   return new RecordSchema(itemSchema, false, [], null, null, {
     type: "videos",
-    accept: (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_VIDEO_ACCEPT,
-    dir: options.dir,
+    accept: (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : DEFAULT_VIDEO_ACCEPT,
+    dir: dir,
     remote: false,
     altSchema: altSchema,
-    stream: options.stream
+    stream: options === null || options === void 0 ? void 0 : options.stream
   });
-};
+}
 
 /**
  * The video schema a set's entry is hashed against, for a remote ref.
@@ -12936,6 +13364,14 @@ function initSchema(options) {
     font: remoteFont,
     video: remoteVideo,
     richtext: remoteRichtext,
+    imagedir: remoteImagedir,
+    filedir: function (dir, options) {
+      return filedir(dir, options).remote();
+    },
+    fontdir: function (dir, options) {
+      return fontdir(dir, options).remote();
+    },
+    videodir: remoteVideodir,
     imageset: function (options) {
       return imageset(options).remote();
     },
@@ -12954,6 +13390,10 @@ function initSchema(options) {
     font: font,
     video: video,
     richtext: richtext,
+    imagedir: imagedir,
+    filedir: filedir,
+    fontdir: fontdir,
+    videodir: videodir,
     imageset: imageset,
     fileset: fileset,
     fontset: fontset,
@@ -12966,6 +13406,7 @@ function initSchema(options) {
     array: array,
     object: object,
     number: number,
+    "int": _int,
     discriminatedUnion: discriminatedUnion,
     "enum": enumSchema,
     union: union,
@@ -12979,6 +13420,8 @@ function initSchema(options) {
     file: media.file,
     font: media.font,
     video: media.video,
+    filedir: media.filedir,
+    fontdir: media.fontdir,
     fileset: media.fileset,
     fontset: media.fontset,
     date: date,
@@ -12988,6 +13431,8 @@ function initSchema(options) {
     locale: locale,
     route: route,
     router: router,
+    imagedir: media.imagedir,
+    videodir: media.videodir,
     imageset: media.imageset,
     videoset: media.videoset,
     settings: settings
@@ -14084,7 +14529,7 @@ function _extractValModules() {
  * 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.
@@ -14124,7 +14569,7 @@ function hasRemoteFileSchema(schema) {
     return hasRemoteFileSchema(schema.item);
   } else if (schema.type === "record") {
     /**
-     * A media collection — `s.imageset()` / `s.fileset()` — is the case both of the
+     * A media collection — `s.imagedir()` / `s.filedir()` — is the case both of the
      * old functions were written around, and the one they disagreed on.
      *
      * It has no file or image schema inside it to find: `item` is an object of
@@ -14184,8 +14629,8 @@ function hasRemoteFileSchema(schema) {
  *
  * 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).
@@ -14872,7 +15317,7 @@ function deserializeSchema(serialized) {
   return schema;
 }
 function deserializeSchemaImpl(serialized) {
-  var _serialized$options, _serialized$options2, _serialized$multiline, _serialized$render, _serialized$accept, _serialized$dir, _serialized$remote, _serialized$jsonValue, _serialized$render2, _serialized$external, _serialized$render3, _serialized$render4, _serialized$remote2, _serialized$readonly, _serialized$hidden;
+  var _serialized$options, _serialized$options2, _serialized$multiline, _serialized$render, _serialized$render2, _serialized$accept, _serialized$dir, _serialized$remote, _serialized$jsonValue, _serialized$render3, _serialized$external, _serialized$render4, _serialized$render5, _serialized$remote2, _serialized$readonly, _serialized$hidden;
   switch (serialized.type) {
     case "string":
       return new StringSchema(_objectSpread2(_objectSpread2({}, serialized.options), {}, {
@@ -14884,7 +15329,7 @@ function deserializeSchemaImpl(serialized) {
     case "boolean":
       return new BooleanSchema(serialized.opt, [], false, false, serialized.description);
     case "number":
-      return new NumberSchema(serialized.options, serialized.opt, [], false, false, serialized.description);
+      return new NumberSchema(serialized.options, serialized.opt, [], false, false, serialized.description, null, (_serialized$render = serialized.render) !== null && _serialized$render !== void 0 ? _serialized$render : null);
     case "object":
       return new ObjectSchema(Object.fromEntries(Object.entries(serialized.items).map(function (_ref) {
         var _ref2 = _slicedToArray(_ref, 2),
@@ -14907,7 +15352,7 @@ function deserializeSchemaImpl(serialized) {
     case "array":
       return new ArraySchema(deserializeSchema(serialized.item), serialized.opt, [], false, false, serialized.description,
       // The preview closure cannot survive serialization; the render can.
-      null, (_serialized$render = serialized.render) !== null && _serialized$render !== void 0 ? _serialized$render : null);
+      null, (_serialized$render2 = serialized.render) !== null && _serialized$render2 !== void 0 ? _serialized$render2 : null);
     case "discriminated-union":
       return new DiscriminatedUnionSchema(serialized.key,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -14936,12 +15381,12 @@ function deserializeSchemaImpl(serialized) {
         altSchema: serialized.alt ? deserializeSchema(serialized.alt) : undefined
       } : undefined, false, false, serialized.description, (_serialized$jsonValue = serialized.jsonValues) !== null && _serialized$jsonValue !== void 0 ? _serialized$jsonValue : false,
       // The preview closure cannot survive serialization; the render can.
-      null, (_serialized$render2 = serialized.render) !== null && _serialized$render2 !== void 0 ? _serialized$render2 : null, // The external label is static data, so it survives serialization and
+      null, (_serialized$render3 = serialized.render) !== null && _serialized$render3 !== void 0 ? _serialized$render3 : null, // The external label is static data, so it survives serialization and
       // must be carried back: a deserialized schema that forgot it would walk
       // an external record as if its entries were local.
       (_serialized$external = serialized.external) !== null && _serialized$external !== void 0 ? _serialized$external : null);
     case "keyOf":
-      return new KeyOfSchema(serialized.schema, serialized.path, serialized.opt, [], false, false, serialized.description, (_serialized$render3 = serialized.render) !== null && _serialized$render3 !== void 0 ? _serialized$render3 : null);
+      return new KeyOfSchema(serialized.schema, serialized.path, serialized.opt, [], false, false, serialized.description, (_serialized$render4 = serialized.render) !== null && _serialized$render4 !== void 0 ? _serialized$render4 : null);
     case "locale":
       {
         return new LocaleSchema(serialized.opt, [], false, false, serialized.description);
@@ -14959,7 +15404,7 @@ function deserializeSchemaImpl(serialized) {
     case "image":
       return new ImageSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description);
     case "video":
-      return new VideoSchema(serialized.options, serialized.opt, serialized.remote, [], false, false, serialized.description, (_serialized$render4 = serialized.render) !== null && _serialized$render4 !== void 0 ? _serialized$render4 : null, null, serialized.referencedModule ? {
+      return new VideoSchema(serialized.options, serialized.opt, serialized.remote, [], false, false, serialized.description, (_serialized$render5 = serialized.render) !== null && _serialized$render5 !== void 0 ? _serialized$render5 : null, null, serialized.referencedModule ? {
         modulePath: serialized.referencedModule,
         entries: null,
         remote: (_serialized$remote2 = serialized.remote) !== null && _serialized$remote2 !== void 0 ? _serialized$remote2 : false
@@ -15018,11 +15463,12 @@ function deserializeSchemaImpl(serialized) {
  */
 /**
  * A RENDER is how a field is laid out in the editor, and it applies only when
- * you are looking at the field. It is declared by a CONTAINER about its
- * children, never by a child about itself: `s.array(item).render({ as: "inline" })`
- * and `s.record(item).render({ as: "inline" })`. The one other schema that takes
- * a render is `s.keyOf(...)`, where it means something of its own (see
- * `KeyOfSchema.render`).
+ * you are looking at the field. On a list it is declared by the CONTAINER about
+ * its children, never by a child about itself: `s.array(item).render({ as: "inline" })`
+ * and `s.record(item).render({ as: "inline" })`. Two other schemas take a
+ * render, each meaning something of its own: `s.keyOf(...)` (see
+ * `KeyOfSchema.render`) and `s.number()` / `s.int()`, whose `{ as: "slider" }`
+ * is a different input for the same value (see {@link SliderRender}).
  *
  * Why the container: inline is a property of the LIST — "my items are edited in
  * their rows" — and the item schema is the wrong place to say it. An item can be
@@ -15066,7 +15512,7 @@ function deserializeSchemaImpl(serialized) {
  * `s.array(s.object({ tags: s.array(s.string()) })).render({ as: "inline" })`
  * the objects are inline and `tags` keeps its own default.
  *
- * Not available on `s.router(...)`, `s.imageset(...)` or `s.fileset(...)`:
+ * Not available on `s.router(...)`, `s.imagedir(...)` or `s.filedir(...)`:
  * pages and media have UIs of their own, and `RecordSchema.render` throws there.
  *
  * On `s.keyOf(...)` the same value means something else: the selected entry's
@@ -15078,6 +15524,33 @@ function deserializeSchemaImpl(serialized) {
  * What `.render(...)` takes, and what the serialized schema carries verbatim.
  */
 
+/**
+ * `{ as: "slider", min, max }` on `s.int()` or `s.number()`: the value is
+ * edited with a slider from `min` to `max`, next to a box that takes a typed
+ * value.
+ *
+ * `min` and `max` are REQUIRED, because a slider without ends is not a slider.
+ * They are the slider's own and are not validation: a value outside them is
+ * still valid content (if the schema allows it), and the field says it is out
+ * of the slider's reach and offers to bring it back. What the schema accepts is
+ * `.min()`, `.max()` and `.step()` on the schema itself.
+ *
+ * The one rule tying the two together: **the slider may only produce values
+ * the schema accepts.** So its range has to lie inside the schema's, its step
+ * has to be a multiple of the schema's step and its `min` on the schema's grid,
+ * and on `s.int()` all of them have to be whole numbers. A schema that breaks
+ * that throws where it is defined — see `NumberSchema`.
+ *
+ * `step` defaults to the schema's `.step()`, and to 1 when there is none.
+ *
+ * Unlike `inline` this is about the field itself — no list reads it, and
+ * {@link isInlineRender} answers `false` for it.
+ */
+
+/**
+ * What `s.number().render(...)` and `s.int().render(...)` take.
+ */
+
 /**
  * Does this CONTAINER edit its items inside their list rows, rather than behind
  * clickable preview rows that navigate to them?
@@ -15659,7 +16132,7 @@ function isPageRouter(routerId) {
 
 var corePackageJson = {
 	name: "@valbuild/core",
-	version: "0.143.0",
+	version: "0.145.0",
 	"private": false,
 	description: "Val - supercharged hard-coded content",
 	repository: {
@@ -15765,6 +16238,7 @@ var Internal = {
     fillFromGallery: fillFromGallery,
     galleriesOf: galleriesOf,
     galleryEntryOf: galleryEntryOf,
+    galleryKeyOf: galleryKeyOf,
     GALLERY_DEFAULT_GROUPS: GALLERY_DEFAULT_GROUPS,
     isHlsVideo: isHlsVideo,
     HLS_MIME_TYPE: HLS_MIME_TYPE
@@ -15785,6 +16259,11 @@ var Internal = {
   rejectScheme: rejectScheme,
   schemeOf: schemeOf,
   UNSAFE_URL_SCHEMES: UNSAFE_URL_SCHEMES,
+  number: {
+    nearestAllowedNumber: nearestAllowedNumber,
+    isOnStep: isOnStep,
+    stepOrigin: stepOrigin
+  },
   color: {
     parseColor: parseColor,
     formatColor: formatColor,