@valbuild/core 0.126.0 → 0.127.0

package/dist/{index-cd25c2dc.esm.js → index-5a6e6398.esm.js}

@@ -161,19 +161,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 = _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 = _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 = _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 = _createForOfIteratorHelper(customValidateFunctions),
-        _step;
+      var _iterator4 = _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 = customValidateFunction(src, ctx);
             if (result) {
@@ -191,9 +389,9 @@ var Schema = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator.f();
+        _iterator4.f();
       }
       return errors;
     }
@@ -292,11 +490,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;
@@ -331,6 +529,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;
@@ -933,6 +1135,18 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       } finally {
         _iterator.f();
       }
+      var _iterator2 = _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],
@@ -1016,7 +1230,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",
@@ -1030,6 +1244,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) {
@@ -1294,7 +1537,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",
@@ -1308,6 +1551,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) {
@@ -1481,6 +1732,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;
@@ -1612,7 +1865,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",
@@ -2033,7 +2286,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",
@@ -2047,6 +2300,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) {
@@ -4457,7 +4724,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",
@@ -4974,6 +5241,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
@@ -5005,6 +5334,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;
@@ -5151,6 +5490,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],
@@ -5190,7 +5534,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.
@@ -5198,8 +5542,79 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           error = _this2.mergeValidationErrors(error, subError);
         }
       });
+      var declaredKeys = this.getDeclaredKeysValidation(path, src);
+      error = this.mergeValidationErrors(error, declaredKeys);
+      var _iterator2 = _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) {
@@ -5894,6 +6309,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
@@ -5932,6 +6364,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.
@@ -5992,6 +6449,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;
@@ -6109,7 +6823,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",
@@ -6205,6 +6919,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.
  *
@@ -6223,6 +7030,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;
@@ -6230,10 +7054,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;
@@ -6286,6 +7124,39 @@ var SettingsSchema = /*#__PURE__*/function (_Schema) {
           }).join(", ")), src, true);
         }
       }
+      var sectionValidate = this.sectionValidate();
+      if (sectionValidate) {
+        var _iterator = _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 = _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;
     }
   }, {
@@ -6331,17 +7202,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",
@@ -6356,16 +7227,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
       };
     }
   }, {
@@ -6375,19 +7247,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;
@@ -6431,11 +7303,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.
  *
@@ -7149,7 +8068,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",
@@ -7286,6 +8205,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;
@@ -7439,7 +8367,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",
@@ -7830,7 +8758,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",
@@ -8604,7 +9532,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",
@@ -8940,7 +9868,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",
@@ -9188,7 +10116,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",
@@ -9936,7 +10864,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",
@@ -10125,6 +11053,7 @@ function initSchema() {
     datetime: datetime,
     color: color,
     code: code,
+    locale: locale,
     route: route,
     router: router,
     images: images,
@@ -10263,6 +11192,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) {
@@ -11049,7 +11980,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;
@@ -11121,7 +12052,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") {
@@ -11400,6 +12331,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 = _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) {
@@ -11411,7 +12382,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), {}, {
@@ -11440,7 +12411,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.
@@ -11477,27 +12453,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;
@@ -12164,7 +13145,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: {
@@ -12335,4 +13316,4 @@ function tryJsonParse(str) {
   }
 }
 
-export { parseNextJsRoutePattern as $, ArraySchema as A, BooleanSchema as B, ColorSchema as C, DEFAULT_CONTENT_HOST as D, COLOR_FORMATS as E, FATAL_ERROR_TYPES as F, GenericSelector as G, DEFAULT_COLOR_FORMAT as H, Internal as I, DateTimeSchema as J, KeyOfSchema as K, RouteSchema as L, ModuleFilePathSep as M, NumberSchema as N, ObjectSchema as O, PatchError as P, RichTextSchema as Q, RecordSchema as R, Schema as S, DiscriminatedUnionSchema as T, EnumSchema as U, VAL_EXTENSION as V, LiteralSchema as W, deserializeSchema as X, previewScope as Y, isInlineRender as Z, _typeof as _, _slicedToArray as a, parseTanStackRoutePattern as a0, tanStackSegmentsOfRoutePath as a1, validateUrlAgainstPattern as a2, getSourcePathFromRoute as a3, isPageRouter as a4, _createClass as b, _classCallCheck as c, _toConsumableArray as d, DEFAULT_APP_HOST as e, extractValModules as f, computeValModuleShas as g, hasRemoteFileSchema as h, initVal as i, hasMediaSchema as j, DEFAULT_VAL_REMOTE_HOST as k, derefPatch as l, modules as m, StringSchema as n, ImageSchema as o, FileSchema as p, DateSchema as q, SettingsSchema as r, splitModuleFilePathAndModulePath as s, ASSISTANT_SETTINGS_MAX_LENGTH as t, assistantAvailability as u, SETTINGS_MODULE_CONVENTION as v, isRootModuleFilePath as w, resolveSettingsModule as x, CodeSchema as y, CODE_LANGUAGES as z };
+export { DiscriminatedUnionSchema as $, ArraySchema as A, BooleanSchema as B, declaredKeySetOf as C, DEFAULT_CONTENT_HOST as D, missingDeclaredKeys as E, FATAL_ERROR_TYPES as F, GenericSelector as G, discriminatedUnionBranchOf as H, Internal as I, ColorSchema as J, CodeSchema as K, LocaleSchema as L, ModuleFilePathSep as M, NumberSchema as N, ObjectSchema as O, PatchError as P, CODE_LANGUAGES as Q, RecordSchema as R, Schema as S, COLOR_FORMATS as T, DEFAULT_COLOR_FORMAT as U, VAL_EXTENSION as V, DateTimeSchema as W, KeyOfSchema as X, RouteSchema as Y, RichTextSchema as Z, _typeof as _, _slicedToArray as a, EnumSchema as a0, LiteralSchema as a1, deserializeSchema as a2, previewScope as a3, isInlineRender as a4, parseNextJsRoutePattern as a5, parseTanStackRoutePattern as a6, tanStackSegmentsOfRoutePath as a7, validateUrlAgainstPattern as a8, getSourcePathFromRoute as a9, isPageRouter as aa, _createClass as b, _classCallCheck as c, _toConsumableArray as d, DEFAULT_APP_HOST as e, extractValModules as f, computeValModuleShas as g, hasRemoteFileSchema as h, initVal as i, hasMediaSchema as j, DEFAULT_VAL_REMOTE_HOST as k, derefPatch as l, modules as m, StringSchema as n, ImageSchema as o, FileSchema as p, DateSchema as q, SettingsSchema as r, splitModuleFilePathAndModulePath as s, ASSISTANT_SETTINGS_MAX_LENGTH as t, assistantAvailability as u, SETTINGS_MODULE_CONVENTION as v, isRootModuleFilePath as w, resolveSettingsModule as x, localeTagError as y, localeOfValue as z };