@valbuild/shared 0.126.0 → 0.127.0

package/internal/dist/valbuild-shared-internal.cjs.prod.js

@@ -1125,6 +1125,16 @@ var SerializedCodeSchema = zod.z.object(getSitemapTree._objectSpread2(getSitemap
   options: CodeOptions.optional(),
   opt: zod.z["boolean"]()
 }));
+var SerializedLocaleSchema = zod.z.object({
+  type: zod.z.literal("locale"),
+  render: FieldRender,
+  preview: zod.z.literal(true).optional(),
+  opt: zod.z["boolean"](),
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional(),
+  description: zod.z.string().optional()
+});
 var SerializedRouteSchema = zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
   type: zod.z.literal("route"),
   options: zod.z.object({
@@ -1150,10 +1160,15 @@ var SerializedSettingsSchema = zod.z.lazy(function () {
   return zod.z.object(getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, commonSchemaFields), {}, {
     type: zod.z.literal("settings"),
     items: zod.z.record(zod.z.string(), SerializedSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    // Which section this is, where Val has rules about it beyond its keys.
+    // Dropping it would leave the Studio's validation worker running every
+    // field's own rules and none of the cross-field ones — see
+    // `sectionValidators` in core/src/schema/settings.ts.
+    section: zod.z.string().optional()
   }));
 });
-var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedSettingsSchema, SerializedImageSchema]);
+var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedLocaleSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedColorSchema, SerializedCodeSchema, SerializedSettingsSchema, SerializedImageSchema]);
 
 var ValCommit = zod.z.object({
   commitSha: zod.z.string(),
@@ -1329,7 +1344,7 @@ var ValConfig = zod.z.object({
   gitCommit: zod.z.string().optional(),
   gitBranch: zod.z.string().optional()
 });
-var ValidationFixZ = zod.z.union([zod.z.literal("image:add-metadata"), zod.z.literal("image:check-metadata"), zod.z.literal("image:check-remote"), zod.z.literal("image:upload-remote"), zod.z.literal("image:download-remote"), zod.z.literal("images:check-remote"), zod.z.literal("images:upload-remote"), zod.z.literal("file:add-metadata"), zod.z.literal("file:check-metadata"), zod.z.literal("file:check-remote"), zod.z.literal("file:upload-remote"), zod.z.literal("file:download-remote"), zod.z.literal("files:check-remote"), zod.z.literal("files:upload-remote"), zod.z.literal("keyof:check-keys"), zod.z.literal("router:check-route"), zod.z.literal("images:check-unique-folder"), zod.z.literal("files:check-unique-folder"), zod.z.literal("images:check-all-files"), zod.z.literal("files:check-all-files"), zod.z.literal("jsonValues:extract-entry")]);
+var ValidationFixZ = zod.z.union([zod.z.literal("image:add-metadata"), zod.z.literal("image:check-metadata"), zod.z.literal("image:check-remote"), zod.z.literal("image:upload-remote"), zod.z.literal("image:download-remote"), zod.z.literal("images:check-remote"), zod.z.literal("images:upload-remote"), zod.z.literal("file:add-metadata"), zod.z.literal("file:check-metadata"), zod.z.literal("file:check-remote"), zod.z.literal("file:upload-remote"), zod.z.literal("file:download-remote"), zod.z.literal("files:check-remote"), zod.z.literal("files:upload-remote"), zod.z.literal("keyof:check-keys"), zod.z.literal("router:check-route"), zod.z.literal("locale:check-locale"), zod.z.literal("record:fill-keys"), zod.z.literal("images:check-unique-folder"), zod.z.literal("files:check-unique-folder"), zod.z.literal("images:check-all-files"), zod.z.literal("files:check-all-files"), zod.z.literal("jsonValues:extract-entry")]);
 var ValidationError = zod.z.object({
   message: zod.z.string(),
   value: zod.z.unknown().optional(),
@@ -3236,7 +3251,7 @@ var compatible = {
  * `readonly Json[]` — so the check that reads naturally does not type. This
  * predicate is that check, said once.
  */
-function isJsonObject(value) {
+function isJsonObject$1(value) {
   return getSitemapTree._typeof(value) === "object" && value !== null && !Array.isArray(value);
 }
 function incompatible(reason) {
@@ -3293,7 +3308,7 @@ function variantOf(schema, value) {
     return undefined;
   }
   var discriminator = schema.key;
-  if (!isJsonObject(value)) {
+  if (!isJsonObject$1(value)) {
     return undefined;
   }
   var tag = value[discriminator];
@@ -3421,7 +3436,7 @@ function checkCompatibility(from, to) {
       }
     case "object":
       {
-        if (from.schema.type !== "object" || !isJsonObject(from.value)) {
+        if (from.schema.type !== "object" || !isJsonObject$1(from.value)) {
           return {
             status: "unknown",
             message: "The old value is not shaped like an object."
@@ -3524,7 +3539,7 @@ function checkCompatibility(from, to) {
       }
     case "record":
       {
-        if (from.schema.type !== "record" || !isJsonObject(from.value)) {
+        if (from.schema.type !== "record" || !isJsonObject$1(from.value)) {
           return {
             status: "unknown",
             message: "The old value is not a record."
@@ -3960,6 +3975,59 @@ function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
     error: false
   };
 }
+
+/**
+ * The languages the project declares, from its settings module.
+ *
+ * Empty where there is no settings module, no `locales` section, or nothing in
+ * it — all of which mean the same thing: this project has not said it is
+ * translated.
+ */
+function declaredLocales(snapshot) {
+  var _resolveSettingsModul = core.resolveSettingsModule(snapshot.schemas),
+    moduleFilePath = _resolveSettingsModul.moduleFilePath;
+  if (moduleFilePath === null) {
+    return [];
+  }
+  var source = snapshot.sources[moduleFilePath];
+  if (getSitemapTree._typeof(source) !== "object" || source === null || Array.isArray(source)) {
+    return [];
+  }
+  var locales = source["locales"];
+  if (getSitemapTree._typeof(locales) !== "object" || locales === null || Array.isArray(locales)) {
+    return [];
+  }
+  var available = locales["available"];
+  if (!Array.isArray(available)) {
+    return [];
+  }
+  return available.filter(function (tag) {
+    return typeof tag === "string";
+  });
+}
+/**
+ * The fixes {@link resolveSchemaSourceFixForError} answers for.
+ *
+ * A marker error carrying one of these is NOT a message: it says "ask the whole
+ * project about this" and carries the value to ask with, because the schema
+ * that raised it can only see its own module. Left unresolved, what a user sees
+ * is the marker's own placeholder text — "should typically be processed by Val
+ * internally … version mismatch" — which is alarming and says nothing.
+ *
+ * A list rather than a check per call site: every caller that resolves some of
+ * these has to resolve all of them, and the two that leaked did so by adding a
+ * fix here and not to a condition somewhere else.
+ */
+var SCHEMA_SOURCE_FIXES = ["keyof:check-keys", "router:check-route", "locale:check-locale", "record:fill-keys"];
+
+/** Whether an error is a marker only the whole project can answer. */
+function isSchemaSourceFixError(error) {
+  var _error$fixes;
+  return ((_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : []).some(function (fix) {
+    return SCHEMA_SOURCE_FIXES.includes(fix);
+  });
+}
+
 /**
  * The record a `keyof:check-keys` error resolves against, or null for any other
  * error — including a malformed marker, which
@@ -3971,8 +4039,8 @@ function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
  * to the referenced record can invalidate the module holding the reference.
  */
 function keyOfRecordPath(error) {
-  var _error$fixes;
-  if (!((_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : []).includes("keyof:check-keys")) {
+  var _error$fixes2;
+  if (!((_error$fixes2 = error.fixes) !== null && _error$fixes2 !== void 0 ? _error$fixes2 : []).includes("keyof:check-keys")) {
     return null;
   }
   var value = error.value;
@@ -3984,15 +4052,15 @@ function keyOfRecordPath(error) {
 }
 
 /**
- * Resolves a single `keyof:check-keys` or `router:check-route` error against
- * the given schema/source snapshot. Returns:
+ * Resolves a single marker error (see {@link SCHEMA_SOURCE_FIXES}) against the
+ * given schema/source snapshot. Returns:
  *   - null if the error is not one of these fixes (caller should pass through)
- *   - { status: "resolved" } if the referenced key/route is valid (drop error)
+ *   - { status: "resolved" } if the reference is valid (drop error)
  *   - { status: "remaining"; error } if invalid (rewritten error to surface)
  */
 function resolveSchemaSourceFixForError(error, snapshot) {
-  var _error$fixes2;
-  var fixes = (_error$fixes2 = error.fixes) !== null && _error$fixes2 !== void 0 ? _error$fixes2 : [];
+  var _error$fixes3;
+  var fixes = (_error$fixes3 = error.fixes) !== null && _error$fixes3 !== void 0 ? _error$fixes3 : [];
   if (fixes.includes("keyof:check-keys")) {
     if (!error.value) {
       return {
@@ -4051,6 +4119,120 @@ function resolveSchemaSourceFixForError(error, snapshot) {
       status: "resolved"
     };
   }
+  if (fixes.includes("locale:check-locale")) {
+    var value = error.value;
+    if (getSitemapTree._typeof(value) !== "object" || value === null) {
+      return {
+        status: "remaining",
+        error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+          message: "Expected locale validation error to have a 'value' object. Found: ".concat(getSitemapTree._typeof(value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var _ref6 = value,
+      locale = _ref6.locale;
+    if (typeof locale !== "string") {
+      return {
+        status: "remaining",
+        error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+          message: "Expected locale validation error 'value' to have property 'locale' of type 'string'. Found: ".concat(getSitemapTree._typeof(locale), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var available = declaredLocales(snapshot);
+    if (available.length === 0) {
+      return {
+        status: "remaining",
+        error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+          // The project has not said it is translated, so the value is not
+          // wrong so much as premature — and the fix is in another file.
+          message: "This project has no languages. Declare them under 'locales.available' in the settings module before using s.locale().",
+          fixes: undefined
+        })
+      };
+    }
+    if (available.includes(locale)) {
+      return {
+        status: "resolved"
+      };
+    }
+    return {
+      status: "remaining",
+      error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+        message: "'".concat(locale, "' is not one of this project's languages: ").concat(available.map(function (each) {
+          return "'".concat(each, "'");
+        }).join(", ")),
+        fixes: undefined
+      })
+    };
+  }
+  if (fixes.includes("record:fill-keys")) {
+    var _value = error.value;
+    if (getSitemapTree._typeof(_value) !== "object" || _value === null) {
+      return {
+        status: "remaining",
+        error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+          message: "Expected record key validation error to have a 'value' object. Found: ".concat(getSitemapTree._typeof(_value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var _ref7 = _value,
+      present = _ref7.present,
+      declared = _ref7.declared;
+    if (!Array.isArray(present)) {
+      return {
+        status: "remaining",
+        error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+          message: "Expected record key validation error 'value' to have property 'present' of type 'array'. Found: ".concat(getSitemapTree._typeof(present), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var presentKeys = present.filter(function (key) {
+      return typeof key === "string";
+    });
+    // A literal union brought its keys along; a locale record left them to be
+    // read out of the settings module, which is the whole reason this check is
+    // resolved here rather than in the schema.
+    var declaredKeys = Array.isArray(declared) ? declared.filter(function (key) {
+      return typeof key === "string";
+    }) : declaredLocales(snapshot);
+    if (declaredKeys.length === 0) {
+      // A locale record on a project that has declared no languages. There is
+      // nothing to require, and the locale field's own check already says the
+      // project has not declared any — saying it twice on one record would not
+      // add anything.
+      return {
+        status: "resolved"
+      };
+    }
+    var missing = core.missingDeclaredKeys(declaredKeys, presentKeys);
+    if (missing.length === 0) {
+      return {
+        status: "resolved"
+      };
+    }
+    return {
+      status: "remaining",
+      error: getSitemapTree._objectSpread2(getSitemapTree._objectSpread2({}, error), {}, {
+        message: "Missing ".concat(missing.length === 1 ? "key" : "keys", ": ").concat(missing.map(function (each) {
+          return "'".concat(each, "'");
+        }).join(", "), ". This record's keys are declared by its schema, so every one of them is an entry \u2014 an entry nobody has written yet is null, not absent."),
+        value: {
+          missing: missing,
+          declared: declaredKeys
+        },
+        fixes: undefined
+      })
+    };
+  }
   if (fixes.includes("router:check-route")) {
     if (!error.value) {
       return {
@@ -4112,10 +4294,10 @@ function asRegExpPattern(value) {
 /**
  * Apply schema/source fix resolution across a map of validation errors.
  *
- * Errors with `keyof:check-keys` or `router:check-route` are resolved against
- * the in-memory schema/source snapshot — valid references drop the error,
- * invalid ones are rewritten with a "did you mean…" message and have their
- * `fixes` cleared (so downstream code reports them as plain validation errors).
+ * Errors carrying one of {@link SCHEMA_SOURCE_FIXES} are resolved against the
+ * in-memory schema/source snapshot — valid references drop the error, invalid
+ * ones are rewritten with a "did you mean…" message and have their `fixes`
+ * cleared (so downstream code reports them as plain validation errors).
  * All other errors pass through untouched.
  *
  * Source paths with no remaining errors are removed from the result.
@@ -4149,6 +4331,189 @@ function resolveSchemaSourceFixes(validationErrors, snapshot) {
   return result;
 }
 
+/**
+ * Which of the project's languages governs a path, or `null` for none.
+ *
+ * THE question the whole feature turns on. A locale scope is a subtree in one
+ * language, and three things open one: a `locale` field on an object, a record
+ * keyed by `s.locale()`, and a locale segment in a segmented key. Once this can
+ * be answered from the schema and the source alone, everything downstream falls
+ * out of it — the Studio's locale filter, deep links, `<html lang>`, and knowing
+ * what to translate from and into.
+ *
+ * One implementation, so the Studio, the server and the validation worker cannot
+ * disagree about what language a piece of content is in.
+ *
+ * `null` means no scope governs the path — which is the answer for most content
+ * in most projects, and for every project that has not declared any languages.
+ */
+function localeAt(path, snapshot) {
+  var available = declaredLocales(snapshot);
+  if (available.length === 0) {
+    // Nothing can be one of no languages. Answering `null` rather than reading
+    // the content is also what makes this cheap for the projects that are not
+    // translated at all.
+    return null;
+  }
+  var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(path),
+    _Internal$splitModule2 = _slicedToArray(_Internal$splitModule, 2),
+    moduleFilePath = _Internal$splitModule2[0],
+    modulePath = _Internal$splitModule2[1];
+  var schema = snapshot.schemas[moduleFilePath];
+  var source = snapshot.sources[moduleFilePath];
+  if (schema === undefined || source === undefined) {
+    return null;
+  }
+  var segments = modulePath ? core.Internal.splitModulePath(modulePath) : [];
+  return walk(schema, source, segments, available);
+}
+
+/**
+ * Walk from a node towards `segments`, answering with the innermost scope.
+ *
+ * The scope is read on ARRIVAL at each node — the node the path names included,
+ * not only the ones passed through on the way to it. So `localeAt` of a
+ * scope-opening object is that object's own locale rather than its parent's,
+ * and a path that stops AT a block still answers with the block's language.
+ *
+ * A scope may not contain another (see `localeScopeErrors`), so at most one of
+ * these can fire on a well-formed path; taking the innermost is what makes the
+ * answer well-defined while a project is mid-fix.
+ */
+function walk(schema, source, segments, available) {
+  var entered = enter(schema, source, available);
+  var locale = entered.locale;
+  var currentSchema = entered.schema;
+  var currentSource = source;
+  var _iterator = getSitemapTree._createForOfIteratorHelper(segments),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var segment = _step.value;
+      if (currentSchema === undefined) {
+        return locale;
+      }
+      if (currentSchema.type === "record") {
+        var _currentSchema$key;
+        if (((_currentSchema$key = currentSchema.key) === null || _currentSchema$key === void 0 ? void 0 : _currentSchema$key.type) === "locale") {
+          // In a locale-keyed record the KEY is the language, so the segment we
+          // are about to take is the answer.
+          var resolved = core.localeOfValue(segment, available);
+          if (resolved !== null) {
+            locale = resolved;
+          }
+        }
+        currentSchema = currentSchema.item;
+      } else if (currentSchema.type === "array") {
+        currentSchema = currentSchema.item;
+      } else if (currentSchema.type === "object" || currentSchema.type === "settings") {
+        currentSchema = currentSchema.items[segment];
+      } else {
+        // A leaf, or richtext's internal structure. Nothing below opens a scope.
+        return locale;
+      }
+      currentSource = childSource(currentSource, segment);
+      entered = enter(currentSchema, currentSource, available);
+      currentSchema = entered.schema;
+      if (entered.locale !== null) {
+        locale = entered.locale;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return locale;
+}
+
+/**
+ * Arrive at a node: resolve what it really is, and read the scope it opens.
+ *
+ * A discriminated union is a fork rather than a level — the variant the value
+ * takes IS the node — so it is resolved here, before anything asks what the
+ * node holds. Doing that on arrival rather than on the way down is the
+ * difference between a block's own path answering with its language and
+ * answering with nothing.
+ */
+function enter(schema, source, available) {
+  var resolved = (schema === null || schema === void 0 ? void 0 : schema.type) === "discriminated-union" ? variantOfUnion(schema, source) : schema;
+  return {
+    schema: resolved,
+    locale: resolved === undefined ? null : localeOfObjectField(resolved, source, available)
+  };
+}
+
+/**
+ * The language an object's own `locale` field says it is in, if it has one.
+ *
+ * Reads the SOURCE, since unlike a record key the value is content rather than
+ * part of the path. A field that has not been filled in, or holds something
+ * that is not one of the project's languages, is not an answer — validation is
+ * already reporting that, and guessing here would put a language in
+ * `<html lang>` that nobody chose.
+ */
+function localeOfObjectField(schema, source, available) {
+  if (schema.type !== "object" || !isJsonObject(source)) {
+    return null;
+  }
+  for (var _i = 0, _Object$entries = Object.entries(schema.items); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      item = _Object$entries$_i[1];
+    if (item.type !== "locale") {
+      continue;
+    }
+    var value = source[key];
+    if (typeof value !== "string") {
+      return null;
+    }
+    return core.localeOfValue(value, available);
+  }
+  return null;
+}
+
+/**
+ * The variant a value takes, or `undefined` if the tag matches none.
+ *
+ * The tag is read off the source here; picking the variant is
+ * {@link discriminatedUnionBranchOf}, shared with the Studio's locale filter so
+ * the two cannot disagree about which variant a row is. `s.enum()` never
+ * reaches this — it is a leaf, with nothing under it to walk into.
+ */
+function variantOfUnion(schema, source) {
+  if (!isJsonObject(source)) {
+    return undefined;
+  }
+  return core.discriminatedUnionBranchOf(schema, source[schema.key]);
+}
+
+/** The child of a source value at a segment, or `null` where there is none. */
+function childSource(source, segment) {
+  var _source$segment;
+  if (Array.isArray(source)) {
+    var _source$index;
+    var index = Number(segment);
+    return Number.isInteger(index) ? (_source$index = source[index]) !== null && _source$index !== void 0 ? _source$index : null : null;
+  }
+  if (!isJsonObject(source)) {
+    return null;
+  }
+  return (_source$segment = source[segment]) !== null && _source$segment !== void 0 ? _source$segment : null;
+}
+
+/**
+ * Whether `source` is a JSON object rather than an array or a primitive.
+ *
+ * A type predicate rather than the inline checks, because `Array.isArray` does
+ * NOT narrow `JsonArray` out of `Json` — it is `readonly Json[]`, and the
+ * built-in guard only narrows mutable arrays. Without this, every read of a
+ * property would need an assertion.
+ */
+function isJsonObject(source) {
+  return getSitemapTree._typeof(source) === "object" && source !== null && !Array.isArray(source);
+}
+
 /**
  * Local `yyyy-MM-dd`, which is the one thing this module used `date-fns` for.
  *
@@ -4185,15 +4550,27 @@ function clampDateTimeString(value, options) {
   }
   return value;
 }
-function emptyOf(schema) {
+
+/**
+ * What `emptyOf` cannot read off a serialized schema.
+ *
+ * The project's languages, and which one is being worked in. Neither is in the
+ * schema: a locale-keyed record has one entry per language and the languages
+ * are declared in the settings module, and "which language am I writing" is a
+ * fact about the editor, not about the content. Optional throughout: a caller
+ * that has no context gets an empty record and an unset locale, which
+ * validation then reports, rather than wrong ones.
+ */
+
+function emptyOf(schema, context) {
   if (schema.type === "object") {
     return Object.fromEntries(Object.keys(schema.items).map(function (key) {
-      return [key, emptyOf(schema.items[key])];
+      return [key, emptyOf(schema.items[key], context)];
     }));
   } else if (schema.type === "array") {
     return [];
   } else if (schema.type === "record") {
-    return {};
+    return emptyRecord(schema, context);
   } else if (schema.type === "settings") {
     // Not an object of empty sections: every settings key is optional, and
     // absent IS the empty value. Filling the sections in would write a shape
@@ -4217,6 +4594,16 @@ function emptyOf(schema) {
     }
   } else if (schema.type === "route") {
     return ""; // Empty string as default route value
+  } else if (schema.type === "locale") {
+    var _context$selectedLoca;
+    // Which languages exist is in the settings module, which `emptyOf` has no
+    // access to — it works from a serialized schema alone. So a caller that
+    // has narrowed to one language says so and gets it; a caller that has not
+    // gets the empty string, which is not a language and which validation
+    // reports. Guessing `locales[0]` instead would file content under a
+    // language nobody chose, which is the thing this whole feature exists to
+    // make visible.
+    return (_context$selectedLoca = context === null || context === void 0 ? void 0 : context.selectedLocale) !== null && _context$selectedLoca !== void 0 ? _context$selectedLoca : "";
   } else if (schema.type === "file" || schema.type === "image") {
     return null; // returning null is the only thing we can do, however, it means that the patches cannot be applied yet since that might fail
   } else if (schema.type === "literal") {
@@ -4229,7 +4616,7 @@ function emptyOf(schema) {
     if (schema.items.length === 0) {
       throw Error("Cannot create an empty value for a discriminated union with no variants");
     }
-    return emptyOf(schema.items[0]);
+    return emptyOf(schema.items[0], context);
   } else if (schema.type === "enum") {
     if (schema.values.length === 0) {
       throw Error("Cannot create an empty value for an enum with no values");
@@ -4255,6 +4642,32 @@ function emptyOf(schema) {
   throw Error("Unexpected schema type: " + JSON.stringify(_exhaustiveCheck));
 }
 
+/**
+ * An empty record — with every key its schema declares already in it.
+ *
+ * An open record (`s.record(s.string(), item)`) starts empty, because there is
+ * no key anyone could mean. A record whose key schema enumerates its keys is
+ * the opposite: the keys are part of the schema, so an empty one is already
+ * missing them, and handing back `{}` would create content that fails
+ * validation the moment it is written.
+ *
+ * The entries are `null` rather than `emptyOf(item)`. A null entry reads as "not
+ * filled in yet", which is what a language nobody has translated into IS —
+ * whereas an entry of empty strings claims someone wrote it and left it blank,
+ * and would count as translated in every list and filter downstream.
+ */
+function emptyRecord(schema, context) {
+  var _context$locales;
+  var declared = core.declaredKeySetOf(schema.key);
+  if (declared === null) {
+    return {};
+  }
+  var keys = declared.kind === "literals" ? declared.keys : (_context$locales = context === null || context === void 0 ? void 0 : context.locales) !== null && _context$locales !== void 0 ? _context$locales : [];
+  return Object.fromEntries(keys.map(function (key) {
+    return [key, null];
+  }));
+}
+
 var toolNames = ["get_all_schema", "get_source", "search_content", "validate_content", "create_patch", "add_session_image_to_gallery", "remove_image_gallery_entry", "navigate_to", "get_current_context", "get_patches", "get_source_path_from_route", "set_session_name", "show_compare_view", "ask_user_question", "duplicate_source", "empty_at_path", "count_entries", "get_record_keys"];
 
 function buildFileRefValue(filePath, metadata) {
@@ -4631,7 +5044,13 @@ function buildEmptyAtPathPatch(args, moduleSchema,
 // Required, not optional: the occupied-key check below is the only thing
 // standing between "scaffold an entry" and "delete the entry that was there",
 // and an optional argument is one a caller forgets.
-moduleSource) {
+moduleSource,
+// The project's languages, for a locale-keyed record: its entries ARE the
+// languages, and they are declared in another module, so an empty one built
+// without them is `{}` — which the completeness rule then reports as every
+// language missing. Both callers can answer: the Studio from the context, the
+// MCP tools from the snapshot they already hold. See `EmptyOfContext`.
+context) {
   var destinationSchema;
   if (args.destinationPath.length === 0) {
     destinationSchema = moduleSchema;
@@ -4677,7 +5096,7 @@ moduleSource) {
   if (occupied) {
     return occupied;
   }
-  var value = emptyOf(destinationSchema);
+  var value = emptyOf(destinationSchema, context);
   return safeParsePatch([{
     op: decision.op,
     path: args.destinationPath,
@@ -4868,6 +5287,8 @@ function isSkippableFixCode(fix) {
       return true;
     case "keyof:check-keys":
     case "router:check-route":
+    case "locale:check-locale":
+    case "record:fill-keys":
     case "jsonValues:extract-entry":
       // `jsonValues:extract-entry` is an entry inlined in the `.val.ts`. The
       // browser cannot fix it (that means writing a new `*.val.json` and
@@ -5275,8 +5696,8 @@ function traverseSchemaSource(source, schema, path, callback) {
     return;
   }
 
-  // Handle route
-  if (schema.type === "route") {
+  // Handle route and locale: both are plain strings at a leaf
+  if (schema.type === "route" || schema.type === "locale") {
     if (typeof source === "string") {
       callback({
         source: source,
@@ -5503,7 +5924,13 @@ function indexModule(searchIndex, moduleFilePath, source, schema) {
     // An enum's value is a string the editor chose; it is as searchable as
     // any other string leaf. The old string union was never indexed at all,
     // which is the gap this closes.
-    schema.type === "enum") {
+    schema.type === "enum" ||
+    // A locale tag, for the same reason: it is what the editor picked and
+    // what they see in the field, so searching "nb-NO" has to find the
+    // Norwegian rows. `traverseSchemaSource` visits these, and visiting a
+    // leaf only to index it as the empty string is worse than not visiting
+    // it — it looks like content that does not exist.
+    schema.type === "locale") {
       var _source$toString, _source$toString2;
       searchText = (_source$toString = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString !== void 0 ? _source$toString : "";
       label = (_source$toString2 = source === null || source === void 0 ? void 0 : source.toString()) !== null && _source$toString2 !== void 0 ? _source$toString2 : "";
@@ -5698,6 +6125,7 @@ exports.RemirrorText = RemirrorText;
 exports.RemirrorTextMark = RemirrorTextMark;
 exports.RestoreVerdict = RestoreVerdict;
 exports.RichTextOptions = RichTextOptions;
+exports.SCHEMA_SOURCE_FIXES = SCHEMA_SOURCE_FIXES;
 exports.SerializedArraySchema = SerializedArraySchema;
 exports.SerializedBooleanSchema = SerializedBooleanSchema;
 exports.SerializedCodeSchema = SerializedCodeSchema;
@@ -5710,6 +6138,7 @@ exports.SerializedFileSchema = SerializedFileSchema;
 exports.SerializedImageSchema = SerializedImageSchema;
 exports.SerializedKeyOfSchema = SerializedKeyOfSchema;
 exports.SerializedLiteralSchema = SerializedLiteralSchema;
+exports.SerializedLocaleSchema = SerializedLocaleSchema;
 exports.SerializedNumberSchema = SerializedNumberSchema;
 exports.SerializedObjectSchema = SerializedObjectSchema;
 exports.SerializedRecordSchema = SerializedRecordSchema;
@@ -5736,6 +6165,7 @@ exports.concatModulePath = concatModulePath;
 exports.createRegExpFromPattern = createRegExpFromPattern;
 exports.createSearchIndex = createSearchIndex;
 exports.createValClient = createValClient;
+exports.declaredLocales = declaredLocales;
 exports.describeContainerAtPath = describeContainerAtPath;
 exports.emptyOf = emptyOf;
 exports.explainIncompatible = explainIncompatible;
@@ -5755,9 +6185,11 @@ exports.getSourceAt = getSourceAt;
 exports.indexModule = indexModule;
 exports.isMimeTypeAccepted = isMimeTypeAccepted;
 exports.isRemoteSchema = isRemoteSchema;
+exports.isSchemaSourceFixError = isSchemaSourceFixError;
 exports.isSkippedSource = isSkippedSource;
 exports.keyOfRecordPath = keyOfRecordPath;
 exports.levenshtein = levenshtein;
+exports.localeAt = localeAt;
 exports.newestCommitSha = newestCommitSha;
 exports.partitionValidationErrors = partitionValidationErrors;
 exports.performSearch = performSearch;