@valbuild/core 0.126.0 → 0.127.0

package/dist/{index-b41b638f.cjs.dev.js → index-889ac441.cjs.dev.js}

@@ -163,19 +163,217 @@ function _inherits(t, e) {
 // import { SerializedI18nSchema } from "./future/i18n";
 // import { SerializedOneOfSchema } from "./future/oneOf";
 
+/**
+ * A locale scope's path, as something to read in a message.
+ *
+ * The walk names the item of an array or record `*`, which says nothing to
+ * whoever has to fix this. `[]` is the convention people already read as "each
+ * of these", and a path that is nothing BUT items has no field to name at all.
+ */
+function describeScopePath(path) {
+  if (path.every(function (segment) {
+    return segment === "*";
+  })) {
+    return "its entries";
+  }
+  var rendered = "";
+  var _iterator = result._createForOfIteratorHelper(path),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var segment = _step.value;
+      if (segment === "*") {
+        rendered += "[]";
+      } else {
+        rendered += rendered === "" ? segment : ".".concat(segment);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return "'".concat(rendered, "'");
+}
 var Schema = /*#__PURE__*/function () {
   function Schema() {
     _classCallCheck(this, Schema);
+    /**
+     * The answer, computed once per schema.
+     *
+     * Memoised because the question is asked from `executeValidate`, which runs
+     * once per SOURCE instance: an array of five hundred blocks asks the item
+     * schema five hundred times, and each answer walks the schema below it
+     * looking for a nested scope. The answer cannot differ between two instances
+     * of the same schema — nothing here reads the source — so the walk is done
+     * once and the result handed back after that.
+     *
+     * The error is still reported at every instance's path. Val's validation
+     * errors are keyed by source path and that is where the Studio draws them, so
+     * a schema error on a row is a schema error on every row; reporting it on one
+     * arbitrary row would put it somewhere nobody was looking.
+     */
+    _defineProperty(this, "localeScopeErrorsMemo", void 0);
   }
   return _createClass(Schema, [{
+    key: "isLocaleField",
+    value:
+    /**
+     * Whether this node is a locale — the field that MARKS a scope, `s.locale()`.
+     *
+     * Only `LocaleSchema` overrides this. A base implementation rather than an
+     * abstract one on purpose: every other schema class answers no, and a
+     * question every class had to answer would be twenty edits for one yes.
+     *
+     * Not the same question as {@link opensLocaleScope}: a locale field marks the
+     * scope, the object AROUND it is the scope. See `localeScope.ts`.
+     */
+    function isLocaleField() {
+      return false;
+    }
+
+    /**
+     * Whether this node OPENS a locale scope, and what opens it.
+     *
+     * An object with a `s.locale()` field opens one; so does a record keyed by
+     * `s.locale()`. Everything below such a node is in that one language, which
+     * is why a scope may not contain another — see `localeScope.ts` for the rule
+     * and the reason it is validated rather than typed.
+     */
+  }, {
+    key: "opensLocaleScope",
+    value: function opensLocaleScope() {
+      return null;
+    }
+
+    /**
+     * The child schemas a locale scope reaches, by the path segment that reaches
+     * them.
+     *
+     * A structural walk that deliberately does NOT go through `executeSerialize`:
+     * serializing a subtree at every node to ask a question about its shape is
+     * quadratic, and this is asked during validation. `*` stands for the item of
+     * an array or record, which has no name of its own.
+     */
+  }, {
+    key: "localeScopeChildren",
+    value: function localeScopeChildren() {
+      return [];
+    }
+
+    /**
+     * Every locale scope opened strictly BELOW this node, by path.
+     *
+     * Stops descending at each one it finds, so a scope three deep is reported
+     * once, by the scope immediately enclosing it, rather than by every ancestor.
+     */
+  }, {
+    key: "localeScopesBelow",
+    value: function localeScopesBelow() {
+      var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var found = [];
+      var _iterator2 = result._createForOfIteratorHelper(this.localeScopeChildren()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _step2.value,
+            key = _step2$value.key,
+            schema = _step2$value.schema;
+          var _path = [].concat(_toConsumableArray(prefix), [key]);
+          var opened = schema.opensLocaleScope();
+          if (opened !== null) {
+            found.push({
+              path: _path,
+              kind: opened
+            });
+            continue;
+          }
+          found.push.apply(found, _toConsumableArray(schema.localeScopesBelow(_path)));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return found;
+    }
+
+    /**
+     * The scope rule, as errors at this node — or `false` if it is not broken.
+     *
+     * Two things are wrong and both are wrong in the SCHEMA rather than in the
+     * content, so both are `schemaError`s: an object with two locale fields (the
+     * subtree below it would be in two languages at once), and a locale scope
+     * inside another (the inner one would silently override the outer for part
+     * of a subtree that is supposed to be one language throughout).
+     *
+     * Validated rather than typed on purpose. Expressing "no scope below this
+     * one" as a constraint means threading it through every schema class's type
+     * parameter, and the errors that fall out of a recursive constraint like
+     * that name the whole tree — an unrelated typo in a `.val.ts` would print
+     * pages. See the design notes on the locales PR.
+     */
+  }, {
+    key: "localeScopeErrors",
+    value: function localeScopeErrors() {
+      if (this.localeScopeErrorsMemo === undefined) {
+        this.localeScopeErrorsMemo = this.computeLocaleScopeErrors();
+      }
+      return this.localeScopeErrorsMemo;
+    }
+  }, {
+    key: "computeLocaleScopeErrors",
+    value: function computeLocaleScopeErrors() {
+      var errors = [];
+      var localeFields = this.localeFieldNames();
+      if (localeFields.length > 1) {
+        errors.push({
+          message: "An object can be in one language, so it can have one locale field. Found ".concat(localeFields.map(function (each) {
+            return "'".concat(each, "'");
+          }).join(", "), "."),
+          schemaError: true
+        });
+      }
+      var opened = this.opensLocaleScope();
+      if (opened !== null) {
+        var _iterator3 = result._createForOfIteratorHelper(this.localeScopesBelow()),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var nested = _step3.value;
+            errors.push({
+              message: "Everything here is already in one language, so ".concat(describeScopePath(nested.path), " cannot set another. Move the ").concat(nested.kind === "key" ? "locale-keyed record" : "locale field", " out of this ").concat(opened === "key" ? "locale-keyed record" : "object", ", or take the outer one away."),
+              schemaError: true
+            });
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+      return errors;
+    }
+
+    /**
+     * This node's own `s.locale()` fields, where it is an object that has any.
+     *
+     * Empty everywhere else, so `localeScopeErrors` can live on the base class.
+     */
+  }, {
+    key: "localeFieldNames",
+    value: function localeFieldNames() {
+      return [];
+    }
+  }, {
     key: "executeCustomValidateFunctions",
     value: function executeCustomValidateFunctions(src, customValidateFunctions, ctx) {
       var errors = [];
-      var _iterator = result._createForOfIteratorHelper(customValidateFunctions),
-        _step;
+      var _iterator4 = result._createForOfIteratorHelper(customValidateFunctions),
+        _step4;
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var customValidateFunction = _step.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var customValidateFunction = _step4.value;
           try {
             var result$1 = customValidateFunction(src, ctx);
             if (result$1) {
@@ -193,9 +391,9 @@ var Schema = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator.f();
+        _iterator4.f();
       }
       return errors;
     }
@@ -294,11 +492,11 @@ var Schema = /*#__PURE__*/function () {
         return incoming;
       }
       for (var pathS in incoming) {
-        var _path = pathS;
-        if (current[_path]) {
-          current[_path] = current[_path].concat(incoming[_path]);
+        var _path2 = pathS;
+        if (current[_path2]) {
+          current[_path2] = current[_path2].concat(incoming[_path2]);
         } else {
-          current[_path] = incoming[_path];
+          current[_path2] = incoming[_path2];
         }
       }
       return current;
@@ -333,6 +531,10 @@ var GetSource = Symbol["for"]("@valbuild/core/GetSource");
 var ValError = Symbol["for"]("@valbuild/core/ValError");
 var GenericSelector = /*#__PURE__*/_createClass(function GenericSelector(valOrExpr, path, schema, error) {
   _classCallCheck(this, GenericSelector);
+  _defineProperty(this, Path, void 0);
+  _defineProperty(this, GetSource, void 0);
+  _defineProperty(this, ValError, void 0);
+  _defineProperty(this, GetSchema, void 0);
   this[Path] = path;
   this[GetSource] = valOrExpr;
   this[ValError] = error;
@@ -935,6 +1137,18 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       } finally {
         _iterator.f();
       }
+      var _iterator2 = result._createForOfIteratorHelper(this.localeScopeErrors()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var scopeError = _step2.value;
+          error = this.appendValidationError(error, path, scopeError.message, src, scopeError.schemaError);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
       for (var _i = 0, _Object$entries = Object.entries(this.items); _i < _Object$entries.length; _i++) {
         var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
           _key = _Object$entries$_i[0],
@@ -1018,7 +1232,7 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     key: "nullable",
     value: function nullable() {
       // Explicit type args: `previewInput` would otherwise pin inference to `Src`.
-      return new ObjectSchema(this.items, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new ObjectSchema(this.items, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -1032,6 +1246,35 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       return new ObjectSchema(this.items, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.renderInput, this.previewInput);
     }
+
+    /** The names of this object's `s.locale()` fields, in declaration order. */
+  }, {
+    key: "localeFieldNames",
+    value: function localeFieldNames() {
+      var _this2 = this;
+      return Object.keys(this.items).filter(function (key) {
+        return _this2.items[key]["isLocaleField"]();
+      });
+    }
+  }, {
+    key: "opensLocaleScope",
+    value: function opensLocaleScope() {
+      // More than one is itself the error, reported by `localeScopeErrors`. It
+      // still opens a scope: reporting "two locale fields" AND "a scope inside a
+      // scope" for the same object would be two errors about one mistake.
+      return this.localeFieldNames().length > 0 ? "field" : null;
+    }
+  }, {
+    key: "localeScopeChildren",
+    value: function localeScopeChildren() {
+      var _this3 = this;
+      return Object.keys(this.items).map(function (key) {
+        return {
+          key: key,
+          schema: _this3.items[key]
+        };
+      });
+    }
   }, {
     key: "executeCustomValidateAt",
     value: function executeCustomValidateAt(path, src) {
@@ -1296,7 +1539,7 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
     key: "nullable",
     value: function nullable() {
       // Explicit type args: `previewInput` would otherwise pin inference to `Src`.
-      return new ArraySchema(this.item, true, [], this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
+      return new ArraySchema(this.item, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.previewInput, this.renderInput);
     }
   }, {
     key: "readonly",
@@ -1310,6 +1553,14 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       return new ArraySchema(this.item, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.previewInput, this.renderInput);
     }
+  }, {
+    key: "localeScopeChildren",
+    value: function localeScopeChildren() {
+      return [{
+        key: "*",
+        schema: this.item
+      }];
+    }
   }, {
     key: "executeCustomValidateAt",
     value: function executeCustomValidateAt(path, src) {
@@ -1483,6 +1734,8 @@ var array = function array(schema) {
 };
 
 var LiteralSchema = /*#__PURE__*/function (_Schema) {
+  /** Type-only marker: as a record key, this declares the key set. See `LocaleSchema`. */
+
   function LiteralSchema(value) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -1614,7 +1867,7 @@ var LiteralSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new LiteralSchema(this.value, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new LiteralSchema(this.value, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -2035,7 +2288,7 @@ var DiscriminatedUnionSchema = /*#__PURE__*/function (_Schema) {
     key: "nullable",
     value: function nullable() {
       // Explicit type args: `previewInput` would otherwise pin inference to `Src`.
-      return new DiscriminatedUnionSchema(this.key, this.items, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new DiscriminatedUnionSchema(this.key, this.items, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -2049,6 +2302,20 @@ var DiscriminatedUnionSchema = /*#__PURE__*/function (_Schema) {
       var isHidden = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       return new DiscriminatedUnionSchema(this.key, this.items, this.opt, this.customValidateFunctions, this.isReadonly, isHidden, this.description, this.renderInput, this.previewInput);
     }
+  }, {
+    key: "localeScopeChildren",
+    value: function localeScopeChildren() {
+      // Every variant is walked under the SAME path: whichever one the value
+      // takes, that is where it sits. `s.enum()` has no children at all — its
+      // values are strings, not schemas — which is why only this half of the old
+      // `s.union` has this.
+      return this.items.map(function (item) {
+        return {
+          key: "*",
+          schema: item
+        };
+      });
+    }
   }, {
     key: "executeCustomValidateAt",
     value: function executeCustomValidateAt(path, src) {
@@ -4459,7 +4726,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new RichTextSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new RichTextSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -4976,6 +5243,68 @@ function hasInlineExternalEntries(source) {
   return _typeof(source) === "object" && source !== null && !Array.isArray(source) && !isExternal(source) && Object.keys(source).length > 0;
 }
 
+/**
+ * The keys a record is REQUIRED to hold, where its key schema says what they are.
+ *
+ * Most records have an open key set — `s.record(s.string(), item)` holds
+ * whatever anyone adds — and this returns `null` for those. A record keyed by
+ * something that enumerates its values is different in kind: the keys are part
+ * of the schema, so a missing one is a hole in the content rather than content
+ * nobody has written yet.
+ *
+ * Two key schemas enumerate. A union of literals does it locally, so its keys
+ * are here. `s.locale()` does it in the settings module, which is another file
+ * and so cannot be read from a serialized schema — that case says only which
+ * kind it is, and is resolved against `locales.available` by
+ * `resolveSchemaSourceFixes`, the same crossing `keyOf` and `route` make.
+ */
+
+/**
+ * What `key` requires a record to hold, or `null` where it requires nothing.
+ *
+ * Works from the SERIALIZED schema so that the Studio, the validation worker
+ * and the server all answer this the same way — none of them has the schema
+ * instance, and `SchemaStore` deliberately holds serialized schemas only.
+ */
+function declaredKeySetOf(key) {
+  if (key === undefined) {
+    return null;
+  }
+  if (key.type === "literal") {
+    return {
+      kind: "literals",
+      keys: [key.value]
+    };
+  }
+  if (key.type === "enum") {
+    // An enum names every value it may take, so those values ARE the key set.
+    // `discriminated-union` is deliberately absent: it discriminates objects
+    // and cannot be a record key at all.
+    return {
+      kind: "literals",
+      keys: _toConsumableArray(key.values)
+    };
+  }
+  if (key.type === "locale") {
+    return {
+      kind: "locale"
+    };
+  }
+  return null;
+}
+
+/**
+ * The declared keys a record is missing, in the order the schema declares them.
+ *
+ * Declaration order rather than the source's: this is read as "what is left to
+ * write", and the answer should not reshuffle itself as entries are added.
+ */
+function missingDeclaredKeys(declared, present) {
+  return declared.filter(function (key) {
+    return !present.includes(key);
+  });
+}
+
 /**
  * The source type of a `.jsonValues()` record: every entry value is EITHER a
  * lazily loaded {@link JsonSource} whose resolved content is the (loosened, see
@@ -5007,6 +5336,16 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     var externalLabel = arguments.length > 12 && arguments[12] !== undefined ? arguments[12] : null;
     _classCallCheck(this, RecordSchema);
     _this = _callSuper(this, RecordSchema);
+    /**
+     * The key set this record's schema declares, computed once.
+     *
+     * `declaredKeySetOf` reads a SERIALIZED schema, and serializing the key
+     * schema walks it — twice per validate, and once per record instance, for an
+     * answer that is a property of the schema and cannot move between them. A
+     * schema is built once and validated against many times, so the walk happens
+     * on the first question and not on any after it.
+     */
+    _defineProperty(_this, "declaredKeys", void 0);
     _this.item = item;
     _this.opt = opt;
     _this.customValidateFunctions = customValidateFunctions;
@@ -5153,6 +5492,11 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           error = _objectSpread2(_objectSpread2({}, error), {}, _defineProperty({}, path, [allFilesCheckError]));
         }
       }
+      // A record whose keys are declared by its schema holds every one of them,
+      // and an entry nobody has written yet is `null` rather than absent — so
+      // `null` is a value here, not a value of the wrong type, and the item
+      // schema is not asked about it.
+      var hasDeclaredKeys = this.declaredKeySet() !== null;
       Object.entries(src).forEach(function (_ref5) {
         var _ref6 = _slicedToArray(_ref5, 2),
           key = _ref6[0],
@@ -5192,7 +5536,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
             _this2.markKeyErrorsAtPath(entryErr, subPath);
           }
           error = _this2.mergeValidationErrors(error, entryErr);
-        } else if (_this2.isJsonValues && isJson(elem)) ; else {
+        } else if (hasDeclaredKeys && elem === null) ; else if (_this2.isJsonValues && isJson(elem)) ; else {
           // Falls through for a jsonValues record whose entry content is inlined
           // (loaded in the UI, or hand-authored): same as a plain record — validate
           // the value against the item schema.
@@ -5200,8 +5544,79 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           error = _this2.mergeValidationErrors(error, subError);
         }
       });
+      var declaredKeys = this.getDeclaredKeysValidation(path, src);
+      error = this.mergeValidationErrors(error, declaredKeys);
+      var _iterator2 = result._createForOfIteratorHelper(this.localeScopeErrors()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var scopeError = _step2.value;
+          error = this.appendValidationError(error, path, scopeError.message, src, scopeError.schemaError);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
       return error;
     }
+
+    /**
+     * The check that a record with a DECLARED key set holds every one of them.
+     *
+     * `s.record(s.locale(), item)` has one entry per language and
+     * `s.record(s.union(s.literal("a"), s.literal("b")), item)` has both — the
+     * keys are part of the schema either way, so a missing one is a hole in the
+     * content rather than content nobody has written yet. TypeScript already
+     * demanded both keys of the second; this is the validator catching up, which
+     * is why the two now behave the same.
+     *
+     * Deferred to `resolveSchemaSourceFixes` even for the literal case, where the
+     * keys are known right here: a locale record's keys are in another file, and
+     * one code path for both is one message, one fix and one thing to be wrong.
+     */
+  }, {
+    key: "getDeclaredKeysValidation",
+    value: function getDeclaredKeysValidation(path, src) {
+      if (this.keySchema === null) {
+        return false;
+      }
+      var declared = this.declaredKeySet();
+      if (declared === null) {
+        return false;
+      }
+      return _defineProperty({}, path, [{
+        fixes: ["record:fill-keys"],
+        message: "Did not validate record keys. This error (record:fill-keys) should typically be processed by Val internally. Seeing this error most likely means you have a Val version mismatch.",
+        value: {
+          present: Object.keys(src),
+          declared: declared.kind === "literals" ? declared.keys : null
+        }
+      }]);
+    }
+  }, {
+    key: "declaredKeySet",
+    value: function declaredKeySet() {
+      if (this.declaredKeys === undefined) {
+        this.declaredKeys = this.keySchema === null ? null : declaredKeySetOf(this.keySchema["executeSerialize"]());
+      }
+      return this.declaredKeys;
+    }
+  }, {
+    key: "opensLocaleScope",
+    value: function opensLocaleScope() {
+      return this.keySchema !== null && this.keySchema["isLocaleField"]() ? "key" : null;
+    }
+  }, {
+    key: "localeScopeChildren",
+    value: function localeScopeChildren() {
+      // The KEY schema is not a child here. A locale key is what opens this
+      // record's scope; it is not something inside the scope.
+      return [{
+        key: "*",
+        schema: this.item
+      }];
+    }
   }, {
     key: "isRemoteUrl",
     value: function isRemoteUrl(url) {
@@ -5896,6 +6311,23 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
   }]);
 }(Schema);
 
+/**
+ * The source of a record, given what its key schema says about its keys.
+ *
+ * A key schema that ENUMERATES its keys (a union of literals, or `s.locale()`)
+ * makes every one of them an entry of the record, and an entry nobody has
+ * written yet is `null` rather than absent — so the value type widens by
+ * `null`. That is the whole of option F at the type level: a half-translated
+ * record is a record with nulls in it, which is data you can count, filter and
+ * see in a diff, rather than keys that are simply not there.
+ *
+ * For a union of literals TypeScript already required every key, since
+ * `SelectorOfSchema<K>` is the literal union itself. `s.locale()` is a flavoured
+ * string, so it requires nothing here and the requirement is the validator's —
+ * deliberately: which languages exist is in the settings module, where the
+ * project can change it without a deploy.
+ */
+
 // Overload: with key schema
 
 // Overload: without key schema
@@ -5934,6 +6366,31 @@ function record(keyOrSchema, schema) {
  * written without removing the key.
  */
 
+/**
+ * The languages this project publishes.
+ *
+ * Content rather than configuration, and deliberately: which languages a site
+ * has is a decision the people who write it make, and under a build-time
+ * constant it took a developer and a deploy. It is the same move `assistant`
+ * makes with `enabled`.
+ *
+ * Val ships no list of its own. A project with no `locales` section has not
+ * said it is translated, and nothing about locales appears anywhere — no picker
+ * in the Studio, no checks, nothing.
+ *
+ * **This list is a decision with a blast radius.** Every locale in content is
+ * checked against it, so removing one invalidates the content that uses it, and
+ * adding one leaves every locale-keyed record short of a language until it is
+ * filled in. That is the intended behaviour — a language that is declared and
+ * missing everywhere is worth being told about — but it is why the Studio warns
+ * before saving a removal rather than treating this as an ordinary field.
+ *
+ * There is no default language, deliberately. Every locale-specific field asks
+ * which language it is in, and a default is exactly the answer that lets that
+ * question go unanswered — content ends up filed under a language nobody chose,
+ * which is the state translation is meant to make visible.
+ */
+
 /**
  * The assistant: whether editors have one, and what it is told about the
  * project on every message.
@@ -5994,6 +6451,263 @@ settings) {
   return "unconfigured";
 }
 
+/**
+ * One of the languages the project publishes.
+ *
+ * The set is NOT here. It is declared in the settings module — `locales.available`
+ * — so that adding a language is something the people who write the content can
+ * do, and so that one list drives validation, the Studio's picker and the
+ * translation notes. This schema knows only that the value is one of them, which
+ * is checked cross-module through the `locale:check-locale` fix, exactly as
+ * `keyOf` and `route` check theirs.
+ *
+ * Never stega encoded (see `stegaEncode.ts`): a locale goes into `<html lang>`,
+ * into `hreflang` and into `Intl` constructors, none of which survive invisible
+ * characters.
+ */
+var LocaleSchema = /*#__PURE__*/function (_Schema) {
+  /**
+   * Type-only marker: as a record key, this schema DECLARES the key set.
+   *
+   * `declare` so it exists in the type and nowhere at runtime — reading it off
+   * an instance gives `undefined`, and nothing should. It is how `record()`
+   * knows to type entries as `Item | null`: a language nobody has translated
+   * into is a null entry, not an absent key. See `DeclaredKeySet` and
+   * `RecordSrcOf`.
+   */
+
+  function LocaleSchema() {
+    var _this;
+    var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var customValidateFunctions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var isHidden = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var description = arguments.length > 4 ? arguments[4] : undefined;
+    var renderInput = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
+    var previewInput = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+    _classCallCheck(this, LocaleSchema);
+    _this = _callSuper(this, LocaleSchema);
+    _this.opt = opt;
+    _this.customValidateFunctions = customValidateFunctions;
+    _this.isReadonly = isReadonly;
+    _this.isHidden = isHidden;
+    _this.description = description;
+    _this.renderInput = renderInput;
+    _this.previewInput = previewInput;
+    return _this;
+  }
+
+  /**
+   * A note to whoever edits this field, shown under it in the Studio.
+   *
+   * Pass `null` to clear a description set earlier.
+   *
+   * @example
+   * const schema = s.object({
+   *   locale: s.locale().describe("The language everything below is written in"),
+   *   title: s.string(),
+   * });
+   * export default c.define("/example.val.ts", schema, {
+   *   locale: "nb-NO",
+   *   title: "Vinterjakke",
+   * });
+   */
+  _inherits(LocaleSchema, _Schema);
+  return _createClass(LocaleSchema, [{
+    key: "describe",
+    value: function describe(description) {
+      return new LocaleSchema(this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined, this.renderInput, this.previewInput);
+    }
+
+    /**
+     * A check of your own, on top of "is this one of the project's languages".
+     *
+     * Return a message when the value is WRONG and `false` when it is fine — the
+     * two answers are a complaint and no complaint, so write the check as a
+     * ternary rather than as `ok || "message"`, which returns `true` and `true`
+     * is neither.
+     *
+     * @example
+     * const schema = s.object({
+     *   locale: s.locale().validate((val) =>
+     *     val === "en-US" ? "This section is not translated into English yet" : false,
+     *   ),
+     *   title: s.string(),
+     * });
+     * export default c.define("/example.val.ts", schema, {
+     *   locale: "nb-NO",
+     *   title: "Vinterjakke",
+     * });
+     */
+  }, {
+    key: "validate",
+    value: function validate(validationFunction) {
+      return new LocaleSchema(this.opt, this.customValidateFunctions.concat(validationFunction), this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+    }
+  }, {
+    key: "executeValidate",
+    value: function executeValidate(path, src) {
+      var customValidationErrors = this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+      if (this.opt && (src === null || src === undefined)) {
+        return customValidationErrors.length > 0 ? _defineProperty({}, path, customValidationErrors) : false;
+      }
+      if (typeof src !== "string") {
+        return _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          value: src
+        }]);
+      }
+      return _defineProperty({}, path, [].concat(_toConsumableArray(customValidationErrors), [{
+        // Which languages exist is in another module, so this cannot be
+        // answered here — the same shape `keyOf` and `route` use, resolved by
+        // `resolveSchemaSourceFixes` against the settings module.
+        fixes: ["locale:check-locale"],
+        message: "Did not validate locale. This error (locale:check-locale) should typically be processed by Val internally. Seeing this error most likely means you have a Val version mismatch.",
+        value: {
+          locale: src,
+          sourcePath: path
+        }
+      }]));
+    }
+  }, {
+    key: "executeAssert",
+    value: function executeAssert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (typeof src === "string") {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      return {
+        success: false,
+        errors: _defineProperty({}, path, [{
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          typeError: true
+        }])
+      };
+    }
+  }, {
+    key: "nullable",
+    value: function nullable() {
+      // Asserted whole, exactly as `RouteSchema.nullable` does: the source type
+      // widens by `null` while the caller's validators and preview stay typed
+      // against the value, and `executeValidate` returns before either sees one.
+      return new LocaleSchema(true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+    }
+  }, {
+    key: "readonly",
+    value: function readonly() {
+      return new LocaleSchema(this.opt, this.customValidateFunctions, true, this.isHidden, this.description, this.renderInput, this.previewInput);
+    }
+  }, {
+    key: "hidden",
+    value: function hidden() {
+      return new LocaleSchema(this.opt, this.customValidateFunctions, this.isReadonly, true, this.description, this.renderInput, this.previewInput);
+    }
+  }, {
+    key: "isLocaleField",
+    value: function isLocaleField() {
+      return true;
+    }
+  }, {
+    key: "executeCustomValidateAt",
+    value: function executeCustomValidateAt(path, src) {
+      return this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+    }
+
+    /**
+     * How this field is laid out where it is the item of an array or a record.
+     * Static configuration, not a callback — see `render.ts`.
+     *
+     * @example
+     * const schema = s.array(s.locale().render({ as: "inline" }));
+     * export default c.define("/example.val.ts", schema, ["nb-NO", "en-US"]);
+     */
+  }, {
+    key: "render",
+    value: function render(input) {
+      return new LocaleSchema(this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, input, this.previewInput);
+    }
+
+    /**
+     * How this VALUE is shown where a preview of it is needed. Never how the field
+     * itself is edited (that is `render`). See `preview.ts`.
+     *
+     * @example
+     * const schema = s.array(
+     *   s.locale().preview(({ val }) => ({ title: val })),
+     * );
+     * export default c.define("/example.val.ts", schema, ["nb-NO", "en-US"]);
+     */
+  }, {
+    key: "preview",
+    value: function preview(select) {
+      return new LocaleSchema(this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, select);
+    }
+  }, {
+    key: "executePreviewItem",
+    value: function executePreviewItem(src) {
+      if (this.previewInput === null) {
+        return null;
+      }
+      return this.previewInput({
+        val: src
+      });
+    }
+  }, {
+    key: "declaresItemPreview",
+    value: function declaresItemPreview() {
+      return this.previewInput !== null;
+    }
+  }, {
+    key: "executeSerialize",
+    value: function executeSerialize() {
+      var _this$renderInput, _this$customValidateF;
+      return {
+        type: "locale",
+        render: (_this$renderInput = this.renderInput) !== null && _this$renderInput !== void 0 ? _this$renderInput : undefined,
+        preview: this.previewInput ? true : 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,
+        hidden: this.isHidden,
+        description: this.description
+      };
+    }
+  }, {
+    key: "executePreview",
+    value: function executePreview() {
+      return {};
+    }
+  }]);
+}(Schema);
+
+/**
+ * Define one of the project's languages.
+ *
+ * The languages themselves are declared in the settings module, under
+ * `locales.available` — this says only that a value is one of them.
+ *
+ * @example // a field: everything under this object is in this language
+ * const schema = s.object({ locale: s.locale(), title: s.string() });
+ *
+ * @example // a key: one entry per language
+ * const schema = s.record(s.locale(), s.object({ title: s.string() }));
+ */
+var locale = function locale() {
+  return new LocaleSchema();
+};
+
 var BooleanSchema = /*#__PURE__*/function (_Schema) {
   function BooleanSchema() {
     var _this;
@@ -6111,7 +6825,7 @@ var BooleanSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new BooleanSchema(true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new BooleanSchema(true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -6207,6 +6921,99 @@ var _boolean = function _boolean() {
   return new BooleanSchema();
 };
 
+/**
+ * Language tags, and what makes one wrong.
+ *
+ * Val does not ship a list of locales. Which languages a project publishes is a
+ * property of that project, so it is declared in the settings module — see
+ * `LocalesSettingsSource` — and everything downstream reads it from there.
+ *
+ * What Val does own is the SPELLING. A tag is checked against BCP 47
+ * (RFC 5646) through `Intl.getCanonicalLocales`, which is the same
+ * implementation the browser, `<html lang>` and every `Intl` constructor use.
+ * Delegating rather than writing a matcher is the point: a tag this accepts is
+ * a tag those accept.
+ */
+
+/**
+ * What is wrong with `tag` as a language tag, or `false` if nothing is.
+ *
+ * Canonical form, not merely parseable, and the difference is what makes this
+ * worth checking at all. `nb-no` parses; `Intl.DisplayNames` and a
+ * case-sensitive comparison against a stored key do not agree about it. Since a
+ * locale is compared as a string everywhere — a record key, a URL segment, a
+ * value in content — one spelling has to win, and the canonical one is the
+ * spelling every other tool already produces.
+ *
+ * The message names the canonical form where there is one, because "not
+ * canonical" is not an instruction and `nb-NO` is.
+ */
+function localeTagError(tag) {
+  var canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(tag);
+  } catch (_unused) {
+    // RangeError, for anything the grammar rejects: an underscore instead of a
+    // hyphen (`nb_NO`, which is POSIX rather than BCP 47), an empty subtag, a
+    // subtag of the wrong length.
+    return "'".concat(tag, "' is not a language tag. Language then region, separated by a hyphen \u2014 'nb-NO', not 'nb_NO'");
+  }
+  if (canonical.length !== 1) {
+    // A comma-separated list, or something that canonicalised to nothing.
+    return "'".concat(tag, "' is not a single language tag");
+  }
+  if (canonical[0] !== tag) {
+    return "'".concat(tag, "' is not canonical. Write it as '").concat(canonical[0], "'");
+  }
+  return false;
+}
+
+/**
+ * A language tag, as content holds it.
+ *
+ * A *flavoured* string rather than a union or a strict brand. Which languages a
+ * project has is declared in its settings module, where the project can change
+ * it, so there is no set for a type to enumerate — and a strict brand would make
+ * `"nb-NO"` unassignable, which would mean writing every locale in a `.val.ts`
+ * through a constructor. Content stays plain data.
+ *
+ * So this carries no compile-time guarantee, and is not meant to. It names the
+ * concept where a bare `string` would say nothing, and the guarantee is the
+ * `locale:check-locale` validation against `locales.available`.
+ */
+
+/**
+ * The locale a stored value means, or `null` if it means none of them.
+ *
+ * A lookup against the project's languages, and today that is all it is. It
+ * stays a named function because it is the one place the question is asked —
+ * the Studio, the validation worker and the server all come here rather than
+ * comparing strings themselves, so they cannot disagree about what a stored
+ * value is.
+ */
+function localeOfValue(value, available) {
+  return available.includes(value) ? value : null;
+}
+
+/**
+ * A rule about a section that its individual fields cannot state.
+ *
+ * Paths are WITHIN the section, so an error lands on the value it is about —
+ * including a row of a list, which is what makes this different from a
+ * `.validate()` on the field.
+ */
+
+/**
+ * Every section's rules, by the name that travels in the serialized schema.
+ *
+ * Typed with `| undefined` on the value rather than as a `Partial`: the whole
+ * point is that a lookup can miss, because the name comes off a serialized
+ * schema that may have been written by a newer Val than the one reading it.
+ */
+var sectionValidators = {
+  locales: localesSectionErrors
+};
+
 /**
  * An object whose keys are all optional: absent means unset.
  *
@@ -6225,6 +7032,23 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
     var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var isHidden = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var description = arguments.length > 4 ? arguments[4] : undefined;
+    var
+    /**
+     * Which section this is, where Val has rules about it beyond its keys.
+     *
+     * Not the `validate` the class deliberately does not offer: that one is the
+     * schema author's, and `s.settings()` takes no arguments to declare it
+     * with. This names a rule Val states about a shape Val owns — no language
+     * declared twice in `locales.available` is true of every project, and
+     * there is nowhere else it can be said. A single value's rules stay on its
+     * own schema; this is for the ones that need to see more than one value,
+     * or to report on a row of a list.
+     *
+     * A NAME rather than the function, so it survives serialization: the schema
+     * reaches the Studio's validation worker as JSON, and a closure would be
+     * dropped on the way — which is how these rules once went missing there.
+     */
+    section = arguments.length > 5 ? arguments[5] : undefined;
     _classCallCheck(this, SettingsSchema);
     _this = _callSuper(this, SettingsSchema);
     _this.items = items;
@@ -6232,10 +7056,24 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
     _this.isReadonly = isReadonly;
     _this.isHidden = isHidden;
     _this.description = description;
+    _this.section = section;
     return _this;
   }
+
+  /**
+   * This section's rules, or `undefined` where there are none to run.
+   *
+   * A name this Val does not know means a schema written by a newer one. Its
+   * per-field validation still runs; only the section's own rule is missed,
+   * which is the mild half of the failure and better than refusing the schema.
+   */
   _inherits(SettingsSchema, _Schema);
   return _createClass(SettingsSchema, [{
+    key: "sectionValidate",
+    value: function sectionValidate() {
+      return this.section === undefined ? undefined : sectionValidators[this.section];
+    }
+  }, {
     key: "executeValidate",
     value: function executeValidate(path, src) {
       var error = false;
@@ -6288,6 +7126,39 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
           }).join(", ")), src, true);
         }
       }
+      var sectionValidate = this.sectionValidate();
+      if (sectionValidate) {
+        var _iterator = result._createForOfIteratorHelper(sectionValidate(src)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _ref4;
+            var _step$value = _step.value,
+              keys = _step$value.path,
+              message = _step$value.message;
+            var _subPath = path;
+            var _iterator2 = result._createForOfIteratorHelper(keys),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var _key3 = _step2.value;
+                _subPath = _subPath && createValPathOfItem(_subPath, _key3);
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            error = this.appendValidationError(error, // Falls back to the section itself, which is where an error belongs
+            // when the value it is about is not addressable.
+            (_ref4 = _subPath) !== null && _ref4 !== void 0 ? _ref4 : path, message, src);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
       return error;
     }
   }, {
@@ -6333,17 +7204,17 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new SettingsSchema(this.items, true, this.isReadonly, this.isHidden, this.description);
+      return new SettingsSchema(this.items, true, this.isReadonly, this.isHidden, this.description, this.section);
     }
   }, {
     key: "readonly",
     value: function readonly() {
-      return new SettingsSchema(this.items, this.opt, true, this.isHidden, this.description);
+      return new SettingsSchema(this.items, this.opt, true, this.isHidden, this.description, this.section);
     }
   }, {
     key: "hidden",
     value: function hidden() {
-      return new SettingsSchema(this.items, this.opt, this.isReadonly, true, this.description);
+      return new SettingsSchema(this.items, this.opt, this.isReadonly, true, this.description, this.section);
     }
   }, {
     key: "executeCustomValidateAt",
@@ -6358,16 +7229,17 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
     value: function executeSerialize() {
       return {
         type: "settings",
-        items: Object.fromEntries(Object.entries(this.items).map(function (_ref4) {
-          var _ref5 = _slicedToArray(_ref4, 2),
-            key = _ref5[0],
-            schema = _ref5[1];
+        items: Object.fromEntries(Object.entries(this.items).map(function (_ref5) {
+          var _ref6 = _slicedToArray(_ref5, 2),
+            key = _ref6[0],
+            schema = _ref6[1];
           return [key, schema["executeSerialize"]()];
         })),
         opt: this.opt,
         readonly: this.isReadonly,
         hidden: this.isHidden,
-        description: this.description
+        description: this.description,
+        section: this.section
       };
     }
   }, {
@@ -6377,19 +7249,19 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
       if (src === null) {
         return res;
       }
-      for (var _key3 in this.items) {
-        var itemSrc = src[_key3];
+      for (var _key4 in this.items) {
+        var itemSrc = src[_key4];
         if (itemSrc === null || itemSrc === undefined) {
           continue;
         }
-        var subPath = unsafeCreateSourcePath(sourcePath, _key3);
+        var subPath = unsafeCreateSourcePath(sourcePath, _key4);
         if (scope !== undefined && !scope.wantsUnder(subPath)) {
           continue;
         }
-        var itemResult = this.items[_key3]["executePreview"](subPath, itemSrc, scope);
+        var itemResult = this.items[_key4]["executePreview"](subPath, itemSrc, scope);
         for (var keyS in itemResult) {
-          var _key4 = keyS;
-          res[_key4] = itemResult[_key4];
+          var _key5 = keyS;
+          res[_key5] = itemResult[_key5];
         }
       }
       return res;
@@ -6433,11 +7305,58 @@ function settings() {
     assistant: new SettingsSchema({
       enabled: _boolean().nullable().describe("Whether editors have an assistant in this project. Unset means nobody has decided: it is offered, and turned on when someone accepts."),
       context: string().multiline().maxLength(ASSISTANT_SETTINGS_MAX_LENGTH).nullable().describe("Background the assistant would otherwise have to guess: what this site is, who runs it, names and spellings that matter."),
-      tone: string().multiline().maxLength(ASSISTANT_SETTINGS_MAX_LENGTH).nullable().describe("How the assistant should write when it writes content: formal or playful, British or American, how headings are cased.")
-    })
+      tone: string().multiline().maxLength(ASSISTANT_SETTINGS_MAX_LENGTH).nullable().describe("How the assistant should write when it writes content: formal or playful, British or American, how headings are cased."),
+      translation: record(locale(), string().multiline().maxLength(ASSISTANT_SETTINGS_MAX_LENGTH).nullable()).nullable().describe("How to translate into each language: dialect, formality, and the words that stay untranslated.")
+    }),
+    locales: new SettingsSchema({
+      // Nullable because the source type is, and because the Studio writes
+      // `null` for every sibling the first time a section is created.
+      available: array(string()).nullable().describe("The languages this project publishes, as BCP 47 tags: en-US, nb-NO. The order is kept: it is the order of the Studio's picker and of a locale-keyed record's rows.")
+    }, false, false, false, undefined, "locales")
   });
 }
 
+/**
+ * The rules about `locales` that need to see the whole list.
+ *
+ * Two of them, and both report on the ENTRY rather than the list: a tag has to
+ * be spelled canonically, and a language cannot be declared twice. Neither can
+ * live on the item schema — the item sees one string, and "twice" is a fact
+ * about its siblings — and neither can be a `.validate()` on the array either,
+ * since that reports one message on the array itself rather than on the row to
+ * delete.
+ *
+ * Reads defensively rather than asserting the source's type. A settings module
+ * is a file someone edits by hand, and validation runs against whatever is in
+ * it — including the shapes the per-key pass is, in the same breath, reporting.
+ */
+function localesSectionErrors(src) {
+  var errors = [];
+  var raw = Array.isArray(src["available"]) ? src["available"] : [];
+  var seen = new Set();
+  for (var i = 0; i < raw.length; i++) {
+    var tag = raw[i];
+    if (typeof tag !== "string") {
+      // The item's own schema has already said what is wrong with it.
+      continue;
+    }
+    var spelling = localeTagError(tag);
+    if (spelling !== false) {
+      errors.push({
+        path: ["available", i],
+        message: spelling
+      });
+    } else if (seen.has(tag)) {
+      errors.push({
+        path: ["available", i],
+        message: "'".concat(tag, "' is declared twice")
+      });
+    }
+    seen.add(tag);
+  }
+  return errors;
+}
+
 /**
  * What may be WRITTEN as an external record's source, on top of the marker.
  *
@@ -7151,7 +8070,7 @@ var NumberSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new NumberSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new NumberSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -7288,6 +8207,15 @@ var number = function number(options) {
  * discriminated union's variants and must not try to recurse into these.
  */
 var EnumSchema = /*#__PURE__*/function (_Schema) {
+  /**
+   * Type-only marker: as a record key, this declares the key set.
+   *
+   * An enum names every value it may take, so a record keyed by one holds
+   * exactly those keys — the same claim `s.literal()` and `s.locale()` make.
+   * `DiscriminatedUnionSchema` carries no marker: it discriminates objects and
+   * cannot be a record key at all. See `LocaleSchema`.
+   */
+
   function EnumSchema(values) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -7441,7 +8369,7 @@ var EnumSchema = /*#__PURE__*/function (_Schema) {
     key: "nullable",
     value: function nullable() {
       // Explicit type args: `previewInput` would otherwise pin inference to `Src`.
-      return new EnumSchema(this.values, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new EnumSchema(this.values, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -7832,7 +8760,7 @@ var KeyOfSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new KeyOfSchema(this.schema, this.sourcePath, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new KeyOfSchema(this.schema, this.sourcePath, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -8606,7 +9534,7 @@ var DateSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new DateSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new DateSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -8942,7 +9870,7 @@ var DateTimeSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new DateTimeSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new DateTimeSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -9190,7 +10118,7 @@ var CodeSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new CodeSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new CodeSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -9938,7 +10866,7 @@ var ColorSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "nullable",
     value: function nullable() {
-      return new ColorSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
+      return new ColorSchema(this.options, true, this.customValidateFunctions, this.isReadonly, this.isHidden, this.description, this.renderInput, this.previewInput);
     }
   }, {
     key: "readonly",
@@ -10127,6 +11055,7 @@ function initSchema() {
     datetime: datetime,
     color: color,
     code: code,
+    locale: locale,
     route: route,
     router: router,
     images: images,
@@ -10265,6 +11194,8 @@ var Hash = /*#__PURE__*/function () {
     _defineProperty(this, "F", 0x9b05688c | 0);
     _defineProperty(this, "G", 0x1f83d9ab | 0);
     _defineProperty(this, "H", 0x5be0cd19 | 0);
+    _defineProperty(this, "_byte", void 0);
+    _defineProperty(this, "_word", void 0);
     _defineProperty(this, "_size", 0);
     _defineProperty(this, "_sp", 0);
     if (!sharedBuffer || sharedOffset >= N.allocTotal) {
@@ -11051,7 +11982,7 @@ function hasRemoteFileSchema(schema) {
     return false;
   } else if (schema.type === "boolean" ||
   // An enum's values are strings, so there is nothing to look inside.
-  schema.type === "enum" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route") {
+  schema.type === "enum" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" || schema.type === "locale") {
     return false;
   } else {
     var exhaustiveCheck = schema;
@@ -11123,7 +12054,7 @@ function hasMediaSchema(schema) {
     return false;
   } else if (schema.type === "boolean" ||
   // An enum's values are strings, so there is nothing to look inside.
-  schema.type === "enum" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" ||
+  schema.type === "enum" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "code" || schema.type === "keyOf" || schema.type === "route" || schema.type === "locale" ||
   // A settings module holds the assistant's configuration, not content, and
   // nothing in it is media.
   schema.type === "settings") {
@@ -11402,6 +12333,46 @@ function getFileHash(text) {
   return hashToRemoteFileHash(getSHA256Hash(new Uint8Array(text)));
 }
 
+/**
+ * The variant of a discriminated union that a value takes, by its tag.
+ *
+ * A discriminated union is a fork rather than a level: the variant IS the node,
+ * and everything a caller wants to know about that node — its fields, its
+ * `locale` field, the schema to draw it with — is on the variant and not on the
+ * union. Resolving it takes the source, so it cannot be done from the schema
+ * alone, which is why every caller that has only the union ends up needing this.
+ *
+ * `undefined` where the tag matches nothing, rather than a fallback to the first
+ * variant: a value whose tag names no variant is not a member of the union,
+ * validation is already saying so, and reading fields out of the wrong shape
+ * would answer confidently and wrongly.
+ *
+ * `s.enum()` never reaches here — it is a leaf whose values are strings, with no
+ * variants to resolve — so anything that is not a discriminated union answers
+ * `undefined` too.
+ */
+function discriminatedUnionBranchOf(schema, tag) {
+  if ((schema === null || schema === void 0 ? void 0 : schema.type) !== "discriminated-union") {
+    return undefined;
+  }
+  var _iterator = result._createForOfIteratorHelper(schema.items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var discriminator = item.items[schema.key];
+      if ((discriminator === null || discriminator === void 0 ? void 0 : discriminator.type) === "literal" && discriminator.value === tag) {
+        return item;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return undefined;
+}
+
 function deserializeSchema(serialized) {
   var schema = deserializeSchemaImpl(serialized);
   if (serialized.readonly) {
@@ -11413,7 +12384,7 @@ function deserializeSchema(serialized) {
   return schema;
 }
 function deserializeSchemaImpl(serialized) {
-  var _serialized$options, _serialized$options2, _serialized$render, _serialized$multiline, _serialized$render2, _serialized$render3, _serialized$render4, _serialized$render5, _serialized$render6, _serialized$render7, _serialized$render8, _serialized$accept, _serialized$directory, _serialized$remote, _serialized$jsonValue, _serialized$render0, _serialized$external, _serialized$render1, _serialized$render11, _serialized$render12, _serialized$render13, _serialized$render14, _serialized$render15, _serialized$render16;
+  var _serialized$options, _serialized$options2, _serialized$render, _serialized$multiline, _serialized$render2, _serialized$render3, _serialized$render4, _serialized$render5, _serialized$render6, _serialized$render7, _serialized$render8, _serialized$accept, _serialized$directory, _serialized$remote, _serialized$jsonValue, _serialized$render0, _serialized$external, _serialized$render1, _serialized$render12, _serialized$render13, _serialized$render14, _serialized$render15, _serialized$render16, _serialized$render17;
   switch (serialized.type) {
     case "string":
       return new StringSchema(_objectSpread2(_objectSpread2({}, serialized.options), {}, {
@@ -11442,7 +12413,12 @@ function deserializeSchemaImpl(serialized) {
           key = _ref4[0],
           item = _ref4[1];
         return [key, deserializeSchema(item)];
-      })), serialized.opt, false, false, serialized.description);
+      })), serialized.opt, false, false, serialized.description,
+      // Carried through, or the Studio's validation worker — which only ever
+      // sees the deserialized schema — would run every field's own rules and
+      // none of the section's, so a language declared twice would be reported
+      // by the CLI and silently accepted in the Studio.
+      serialized.section);
     case "array":
       return new ArraySchema(deserializeSchema(serialized.item), serialized.opt, [], false, false, serialized.description,
       // The preview closure cannot survive serialization; the render can.
@@ -11479,27 +12455,32 @@ function deserializeSchemaImpl(serialized) {
       (_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$render1 = serialized.render) !== null && _serialized$render1 !== void 0 ? _serialized$render1 : null);
-    case "route":
+    case "locale":
       {
         var _serialized$render10;
+        return new LocaleSchema(serialized.opt, [], false, false, serialized.description, (_serialized$render10 = serialized.render) !== null && _serialized$render10 !== void 0 ? _serialized$render10 : null);
+      }
+    case "route":
+      {
+        var _serialized$render11;
         var routeOptions = serialized.options ? {
           include: serialized.options.include ? new RegExp(serialized.options.include.source, serialized.options.include.flags) : undefined,
           exclude: serialized.options.exclude ? new RegExp(serialized.options.exclude.source, serialized.options.exclude.flags) : undefined
         } : undefined;
-        return new RouteSchema(routeOptions, serialized.opt, [], false, false, serialized.description, (_serialized$render10 = serialized.render) !== null && _serialized$render10 !== void 0 ? _serialized$render10 : null);
+        return new RouteSchema(routeOptions, serialized.opt, [], false, false, serialized.description, (_serialized$render11 = serialized.render) !== null && _serialized$render11 !== void 0 ? _serialized$render11 : null);
       }
     case "file":
-      return new FileSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description, (_serialized$render11 = serialized.render) !== null && _serialized$render11 !== void 0 ? _serialized$render11 : null);
+      return new FileSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description, (_serialized$render12 = serialized.render) !== null && _serialized$render12 !== void 0 ? _serialized$render12 : null);
     case "image":
-      return new ImageSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description, (_serialized$render12 = serialized.render) !== null && _serialized$render12 !== void 0 ? _serialized$render12 : null);
+      return new ImageSchema(serialized.options, serialized.opt, serialized.remote, [], {}, false, false, serialized.description, (_serialized$render13 = serialized.render) !== null && _serialized$render13 !== void 0 ? _serialized$render13 : null);
     case "date":
-      return new DateSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render13 = serialized.render) !== null && _serialized$render13 !== void 0 ? _serialized$render13 : null);
+      return new DateSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render14 = serialized.render) !== null && _serialized$render14 !== void 0 ? _serialized$render14 : null);
     case "dateTime":
-      return new DateTimeSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render14 = serialized.render) !== null && _serialized$render14 !== void 0 ? _serialized$render14 : null);
+      return new DateTimeSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render15 = serialized.render) !== null && _serialized$render15 !== void 0 ? _serialized$render15 : null);
     case "color":
-      return new ColorSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render15 = serialized.render) !== null && _serialized$render15 !== void 0 ? _serialized$render15 : null);
+      return new ColorSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render16 = serialized.render) !== null && _serialized$render16 !== void 0 ? _serialized$render16 : null);
     case "code":
-      return new CodeSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render16 = serialized.render) !== null && _serialized$render16 !== void 0 ? _serialized$render16 : null);
+      return new CodeSchema(serialized.options, serialized.opt, [], false, false, serialized.description, (_serialized$render17 = serialized.render) !== null && _serialized$render17 !== void 0 ? _serialized$render17 : null);
     default:
       {
         var exhaustiveCheck = serialized;
@@ -12166,7 +13147,7 @@ function isPageRouter(routerId) {
 
 var corePackageJson = {
 	name: "@valbuild/core",
-	version: "0.126.0",
+	version: "0.127.0",
 	"private": false,
 	description: "Val - supercharged hard-coded content",
 	repository: {
@@ -12359,6 +13340,7 @@ exports.ImageSchema = ImageSchema;
 exports.Internal = Internal;
 exports.KeyOfSchema = KeyOfSchema;
 exports.LiteralSchema = LiteralSchema;
+exports.LocaleSchema = LocaleSchema;
 exports.ModuleFilePathSep = ModuleFilePathSep;
 exports.NumberSchema = NumberSchema;
 exports.ObjectSchema = ObjectSchema;
@@ -12378,8 +13360,10 @@ exports._toConsumableArray = _toConsumableArray;
 exports._typeof = _typeof;
 exports.assistantAvailability = assistantAvailability;
 exports.computeValModuleShas = computeValModuleShas;
+exports.declaredKeySetOf = declaredKeySetOf;
 exports.derefPatch = derefPatch;
 exports.deserializeSchema = deserializeSchema;
+exports.discriminatedUnionBranchOf = discriminatedUnionBranchOf;
 exports.extractValModules = extractValModules;
 exports.getSourcePathFromRoute = getSourcePathFromRoute;
 exports.hasMediaSchema = hasMediaSchema;
@@ -12388,6 +13372,9 @@ exports.initVal = initVal;
 exports.isInlineRender = isInlineRender;
 exports.isPageRouter = isPageRouter;
 exports.isRootModuleFilePath = isRootModuleFilePath;
+exports.localeOfValue = localeOfValue;
+exports.localeTagError = localeTagError;
+exports.missingDeclaredKeys = missingDeclaredKeys;
 exports.modules = modules;
 exports.parseNextJsRoutePattern = parseNextJsRoutePattern;
 exports.parseTanStackRoutePattern = parseTanStackRoutePattern;