bazis 0.100.6 → 0.100.7

package/README.md

@@ -173,20 +173,25 @@ Import from the subpaths listed in `exports` of `package.json`:
 
 ## Language of built-in texts
 
-Built-in texts are English. Russian sets ship with the package; apply them
-once at startup:
+Built-in texts are English. Russian sets ship with the package:
 
 ```ts
-import { MessageRegistry, RU_VALIDATION_MESSAGES } from "bazis/library/validation";
 import { CodexError, RU_CODEX_MESSAGES } from "bazis/core/infra";
 import { RU_UI_LABELS } from "bazis/core/app";
 
-MessageRegistry.setDefaults(RU_VALIDATION_MESSAGES); // validation errors
-CodexError.useMessages(RU_CODEX_MESSAGES);           // Codex connector errors
-await runApp(AppModule, { ui: { labels: RU_UI_LABELS, surfaces: [/* ... */] } }); // generated UI texts
+CodexError.useMessages(RU_CODEX_MESSAGES); // Codex connector errors
+await runApp(AppModule, {
+  language: "ru",                          // response texts: validation, 404/405, 401/403, binding errors
+  messages: { notFound: "Нет такой страницы" }, // optional: own texts for single keys
+  ui: { labels: RU_UI_LABELS, surfaces: [/* ... */] }, // generated UI texts
+});
 ```
 
-Either call also accepts your own texts for some codes.
+`language` is per application: it is applied when the response is written, so
+two apps in one process keep their own languages. Texts an application passes
+to an error itself (`new NotFoundError("…")`) are never changed. Outside an
+application, `MessageRegistry.setDefaults(RU_VALIDATION_MESSAGES)` switches the
+standalone validation library.
 
 ## Status
 

package/core/app/index.ts

@@ -2,4 +2,5 @@
 // the validation library (it is the composition root, so it may use everything), hiding
 // infrastructure wiring from application code.
 export { runApp, type RunAppOptions } from "./runApp";
+export type { AppLanguage, AppMessages } from "./messages";
 export * from "./ui";

package/core/app/messages.ts

@@ -0,0 +1,44 @@
+import { EN_HTTP_MESSAGES, RU_HTTP_MESSAGES, formatMessage, type HttpMessageKey, type Localize } from "../http/Errors/messages";
+import { KernelError } from "../kernel";
+import { EN_VALIDATION_MESSAGES, MessageRegistry, RU_VALIDATION_MESSAGES, type ValidationCode } from "../../library/validation";
+
+/** Language of the texts the framework writes into responses. */
+export type AppLanguage = "en" | "ru";
+
+/**
+ * Own texts for framework messages, by key: HTTP texts (`notFound`,
+ * `missingParameter`, …), validation codes (`required`, `minLength`, …),
+ * `validationFailed`, `unknownField` and type names (`typeName.number`).
+ * Placeholders: `{property}`, `{min}`, `{name}`, … as in the built-in texts.
+ */
+export type AppMessages = Partial<Record<HttpMessageKey | ValidationCode | "validationFailed" | "unknownField" | `typeName.${string}`, string>>;
+
+const CATALOGS: Readonly<Record<AppLanguage, Readonly<Record<string, string>>>> = {
+  en: { ...EN_HTTP_MESSAGES, ...EN_VALIDATION_MESSAGES },
+  ru: { ...RU_HTTP_MESSAGES, ...RU_VALIDATION_MESSAGES },
+};
+
+/**
+ * The text of a framework message in the application language. Priority:
+ * `messages` > `Validator.setDefaultMessages` > the language catalog >
+ * English. Rendered per server at the response, so two apps in one process
+ * keep their own languages.
+ */
+export function createLocalize(language: AppLanguage = "en", messages: AppMessages = {}): Localize {
+  if (!Object.prototype.hasOwnProperty.call(CATALOGS, language)) {
+    throw new KernelError(`runApp: language "${String(language)}" is not supported. Use one of: ${Object.keys(CATALOGS).join(", ")}.`);
+  }
+  const catalog = CATALOGS[language];
+  const own = messages as Readonly<Record<string, string | undefined>>;
+  const template = (key: string): string | undefined => {
+    if (Object.prototype.hasOwnProperty.call(own, key) && typeof own[key] === "string") return own[key];
+    const override = MessageRegistry.override(key);
+    if (override !== undefined) return override;
+    if (Object.prototype.hasOwnProperty.call(catalog, key)) return catalog[key];
+    return Object.prototype.hasOwnProperty.call(CATALOGS.en, key) ? CATALOGS.en[key] : undefined;
+  };
+  return (key, params) => {
+    const text = template(key);
+    return text === undefined ? undefined : formatMessage(text, params, template);
+  };
+}

package/core/app/runApp.ts

@@ -20,6 +20,7 @@ import {
   type UiProfileV1,
 } from "../../library/ui";
 import { modelValidatorAdapter } from "../../library/validation";
+import { createLocalize, type AppLanguage, type AppMessages } from "./messages";
 import {
   type RunAppUiOptions,
   type RunAppUiSurfaceOptions,
@@ -54,6 +55,22 @@ export interface RunAppOptions {
    * default. Pass your own to replace it.
    */
   readonly validator?: ModelValidator;
+  /**
+   * Language of the texts the framework writes into responses: validation
+   * messages, `Not Found`, `Unauthorized`, a missing parameter, malformed
+   * JSON, … Default `"en"`. Texts the application passes to an error itself
+   * (`new NotFoundError("Книга не найдена")`) are never changed.
+   *
+   * ```ts
+   * await runApp(AppModule, { language: "ru", http: { port: 3000 } });
+   * ```
+   */
+  readonly language?: AppLanguage;
+  /**
+   * Own texts for single framework messages, on top of `language`:
+   * `{ notFound: "Нет такой страницы", required: "Заполните {property}" }`.
+   */
+  readonly messages?: AppMessages;
   /** Fine-tuning of the kernel builder (logger, config sources, ...). */
   readonly configure?: (builder: KernelBuilder) => void;
   /**
@@ -271,6 +288,8 @@ export async function runApp(root: BazisModuleRef, options: RunAppOptions = {}):
  * options ask for. Shared with `startTestApp`, so tests run the same graph.
  */
 export function composeApp(root: BazisModuleRef, options: RunAppOptions = {}): BazisModuleRef {
+  // Checked even without HTTP: an unknown language is a startup error.
+  const localize = createLocalize(options.language, options.messages);
   // Infrastructure and cache are global modules; add them to the graph next to the feature root.
   const globals: BazisModuleRef[] = [];
   if (options.infra !== undefined) {
@@ -308,6 +327,7 @@ export function composeApp(root: BazisModuleRef, options: RunAppOptions = {}): B
       options.http,
     );
     const httpRoot = httpModule({
+      localize,
       ...options.http,
       validator,
       imports: [httpAppRoot],

package/core/http/Binding/ParameterBinder.ts

@@ -1,5 +1,5 @@
 import { ListQueryError, parseListQuery } from "../../../library/jsonapi";
-import { BadRequestError, UnsupportedMediaTypeError } from "../Errors/HttpError";
+import { UnsupportedMediaTypeError, frameworkBadRequest } from "../Errors/HttpError";
 import type { HttpContext } from "../HttpContext/HttpContext";
 import type { ParameterBinding } from "./bindings";
 import { convertOr400 } from "./convert";
@@ -33,7 +33,7 @@ function bindValue(binding: ParameterBinding, raw: string | undefined, kind: str
     if (binding.optional) {
       return undefined;
     }
-    throw new BadRequestError(`Missing required ${kind} parameter "${binding.name}"`);
+    throw frameworkBadRequest("missingParameter", { kind, name: binding.name });
   }
   return binding.type && binding.type !== "string" ? convertOr400(raw, binding.type, binding.name ?? "?") : raw;
 }
@@ -114,7 +114,7 @@ export async function bindArguments(
           parsed = parseListQuery(ctx.url.searchParams, binding.listOptions);
         } catch (error) {
           if (error instanceof ListQueryError) {
-            throw new BadRequestError("Invalid list query", error.problems);
+            throw frameworkBadRequest("invalidListQuery", undefined, error.problems);
           }
           throw error;
         }

package/core/http/Binding/convert.ts

@@ -1,4 +1,4 @@
-import { BadRequestError } from "../Errors/HttpError";
+import { frameworkBadRequest } from "../Errors/HttpError";
 
 /** Primitive conversion targets for query/header/route values. */
 export type ValueType = "string" | "int" | "number" | "bool";
@@ -42,7 +42,7 @@ export function tryConvert(raw: string, type: ValueType): string | number | bool
 export function convertOr400(raw: string, type: ValueType, parameterName: string): string | number | boolean {
   const value = tryConvert(raw, type);
   if (value === INVALID) {
-    throw new BadRequestError(`Parameter "${parameterName}" must be of type ${type}, got: "${raw}"`);
+    throw frameworkBadRequest("invalidParameter", { name: parameterName, type, value: raw });
   }
   return value;
 }

package/core/http/Binding/modelBinder.ts

@@ -1,5 +1,5 @@
 import type { Class } from "../../di";
-import { BadRequestError, ModelValidationError } from "../Errors/HttpError";
+import { ModelValidationError, frameworkBadRequest } from "../Errors/HttpError";
 import { getModelValidator, type ModelValidationIssue, type ModelValidationResult, type ModelValidator } from "./modelValidator";
 import {
   findRequestModelShape,
@@ -19,7 +19,7 @@ interface BindingTraversal {
   readonly options: ModelBindingOptions;
   /** Per-field binding problems; a bad field does not stop the other fields. */
   readonly issues: ModelValidationIssue[];
-  readonly typeMessage?: (property: string, expected: string, actual: string) => string;
+  readonly validator?: ModelValidator;
   nodes: number;
 }
 
@@ -74,12 +74,9 @@ export async function bindModelAsync<T extends object>(model: Class<T>, data: un
 
 function hydrate<T extends object>(model: Class<T>, data: unknown, validator: ModelValidator | undefined, options: ModelBindingOptions): { instance: T; traversal: BindingTraversal } {
   if (!isPlainJsonObject(data)) {
-    throw new BadRequestError("Request body must be a JSON object");
+    throw frameworkBadRequest("bodyNotObject");
   }
-  const traversal: BindingTraversal = {
-    stack: new WeakSet(), nodes: 0, options, issues: [],
-    typeMessage: validator?.typeMismatchMessage?.bind(validator),
-  };
+  const traversal: BindingTraversal = { stack: new WeakSet(), nodes: 0, options, issues: [], validator };
   const instance = hydrateModel(model as RequestModelClass, data, "", traversal, 0) as T;
   return { instance, traversal };
 }
@@ -92,7 +89,7 @@ function finish(traversal: BindingTraversal, validator: ModelValidator | undefin
   const bound = new Set(traversal.issues.map((issue) => issue.property));
   const errors = [...traversal.issues, ...(result?.errors ?? []).filter((error) => !bound.has(error.property))];
   if (errors.length > 0) {
-    throw new ModelValidationError(errors, validator?.failureTitle?.() ?? "Validation failed");
+    throw new ModelValidationError(errors, validator?.message?.("validationFailed", {}) ?? "Validation failed");
   }
 }
 
@@ -120,7 +117,7 @@ function hydrateModel(
         target[key] = bindField(model, key, target[key], source[key], fieldPath, traversal, depth + 1);
       } catch (error) {
         if (!(error instanceof BindingTypeError) && !(error instanceof ModelValidationError && error.errors.every((issue) => issue.code === "unknownField"))) throw error;
-        traversal.issues.push(...(error instanceof BindingTypeError ? [error.issue(traversal.typeMessage)] : error.errors));
+        traversal.issues.push(...error.errors.map((issue) => inValidatorLanguage(issue, traversal.validator)));
       }
     }
     return instance;
@@ -209,13 +206,15 @@ function hydrateField(
 
 /** A JSON value of the wrong type; the field is skipped and the binding goes on. */
 class BindingTypeError extends ModelValidationError {
-  constructor(readonly property: string, readonly expected: string, readonly actual: string) {
-    super([{ property, message: `Field "${property}" must be a ${expected}`, code: "type" }]);
+  constructor(property: string, expected: string, actual: string) {
+    super([{ property, message: `Field "${property}" must be a ${expected}`, code: "type", params: { property, expected, actual } }]);
   }
+}
 
-  issue(format?: (property: string, expected: string, actual: string) => string): ModelValidationIssue {
-    return { property: this.property, message: format?.(this.property, this.expected, this.actual) ?? this.errors[0]!.message, code: "type" };
-  }
+/** A binder issue in the validator's current language; the key stays for the response. */
+function inValidatorLanguage(issue: ModelValidationIssue, validator: ModelValidator | undefined): ModelValidationIssue {
+  if (validator?.message === undefined || issue.code === undefined || issue.params === undefined) return issue;
+  return { ...issue, message: validator.message(issue.code, issue.params) };
 }
 
 function bindingTypeError(property: string, expected: string, value: unknown): BindingTypeError {
@@ -319,7 +318,7 @@ function enterContainer(
 ): void {
   const property = path || "$";
   if (depth > MAX_JSON_DEPTH) {
-    throw new BadRequestError("Request body is too deeply nested", {
+    throw frameworkBadRequest("bodyTooDeep", undefined, {
       property,
       maxDepth: MAX_JSON_DEPTH,
     });
@@ -327,13 +326,13 @@ function enterContainer(
   const childCount = Array.isArray(value) ? value.length : Object.keys(value).length;
   traversal.nodes += 1 + childCount;
   if (traversal.nodes > MAX_JSON_NODES) {
-    throw new BadRequestError("Request body is too complex", {
+    throw frameworkBadRequest("bodyTooComplex", undefined, {
       property,
       maxNodes: MAX_JSON_NODES,
     });
   }
   if (traversal.stack.has(value)) {
-    throw new BadRequestError("Request body must be acyclic JSON", { property });
+    throw frameworkBadRequest("bodyCyclic", undefined, { property });
   }
   traversal.stack.add(value);
 }
@@ -352,7 +351,7 @@ function acceptKey(source: object, key: string, allowed: ReadonlySet<string> | u
   if (!FORBIDDEN_KEYS.has(key) && (allowed === undefined || allowed.has(key))) return true;
   if (options.unknownFields === "reject") {
     const property = path === "" ? key : `${path}.${key}`;
-    throw new ModelValidationError([{ property, message: `Field "${property}" is forbidden or not declared by the model.`, code: "unknownField" }]);
+    throw new ModelValidationError([{ property, message: `Field "${property}" is forbidden or not declared by the model.`, code: "unknownField", params: { property } }]);
   }
   return false;
 }

package/core/http/Binding/modelValidator.ts

@@ -11,6 +11,12 @@ export interface ModelValidationIssue {
   readonly property: string;
   readonly message: string;
   readonly code?: string;
+  /**
+   * Placeholder values of a message built from the engine template for `code`:
+   * the error handler re-renders it in the application language. Absent when
+   * the message is the rule's own text (`@Validator({ message })`).
+   */
+  readonly params?: Readonly<Record<string, unknown>>;
 }
 
 export interface ModelValidationResult {
@@ -22,10 +28,12 @@ export interface ModelValidator {
   validate(instance: object): ModelValidationResult;
   /** Async rules (custom checks returning a Promise). HTTP binding prefers it when present. */
   validateAsync?(instance: object): Promise<ModelValidationResult>;
-  /** Text for a JSON value of the wrong type; without it the binder uses its English default. */
-  typeMismatchMessage?(property: string, expected: string, actual: string): string;
-  /** Title of a 400 validation response; without it "Validation failed". */
-  failureTitle?(): string;
+  /**
+   * Text of a message the binder writes itself (`type`, `unknownField`,
+   * `validationFailed`) in the engine's current language; without it the
+   * binder uses English.
+   */
+  message?(code: string, params: Readonly<Record<string, unknown>>): string;
 }
 
 let activeValidator: ModelValidator | undefined;

package/core/http/Errors/HttpError.ts

@@ -1,4 +1,5 @@
 import type { ModelValidationIssue } from "../Binding/modelValidator";
+import { englishHttpMessage, type HttpMessageKey, type LocalizedMessage, type MessageParams } from "./messages";
 
 /**
  * Base class for errors that map directly to an HTTP response.
@@ -10,53 +11,68 @@ export class HttpError extends Error {
     readonly status: number,
     message: string,
     readonly details?: unknown,
+    /**
+     * Key and parameters of the message: the error handler renders it in the
+     * application language (`runApp({ language, messages })`); `message` is the
+     * English text. Errors created with their own text have no key.
+     */
+    readonly localized?: LocalizedMessage,
   ) {
     super(message);
     this.name = new.target.name;
   }
 }
 
+/** Own text as is, or the framework text by key (translated at the response). */
+function textOf(message: string | undefined, key: HttpMessageKey, params?: MessageParams): readonly [string, LocalizedMessage | undefined] {
+  return message !== undefined ? [message, undefined] : [englishHttpMessage(key, params), params === undefined ? { key } : { key, params }];
+}
+
 export class BadRequestError extends HttpError {
-  constructor(message = "Bad Request", details?: unknown) {
-    super(400, message, details);
+  constructor(message?: string, details?: unknown) {
+    const [text, localized] = textOf(message, "badRequest");
+    super(400, text, details, localized);
   }
 }
 
 export class UnauthorizedError extends HttpError {
   readonly challenge = "Bearer";
 
-  constructor(message = "Unauthorized", details?: unknown) {
-    super(401, message, details);
+  constructor(message?: string, details?: unknown) {
+    const [text, localized] = textOf(message, "unauthorized");
+    super(401, text, details, localized);
   }
 }
 
 export class ForbiddenError extends HttpError {
-  constructor(message = "Forbidden", details?: unknown) {
-    super(403, message, details);
+  constructor(message?: string, details?: unknown) {
+    const [text, localized] = textOf(message, "forbidden");
+    super(403, text, details, localized);
   }
 }
 
 export class NotFoundError extends HttpError {
-  constructor(message = "Not Found", details?: unknown) {
-    super(404, message, details);
+  constructor(message?: string, details?: unknown) {
+    const [text, localized] = textOf(message, "notFound");
+    super(404, text, details, localized);
   }
 }
 
 export class MethodNotAllowedError extends HttpError {
   constructor(readonly allow: readonly string[]) {
-    super(405, "Method Not Allowed");
+    super(405, englishHttpMessage("methodNotAllowed"), undefined, { key: "methodNotAllowed" });
   }
 }
 
 export class UnsupportedMediaTypeError extends HttpError {
   constructor(expected: string) {
-    super(415, `Unsupported Media Type: expected ${expected}`);
+    super(415, englishHttpMessage("unsupportedMediaType", { expected }), undefined, { key: "unsupportedMediaType", params: { expected } });
   }
 }
 
 export class PayloadTooLargeError extends HttpError {
   constructor(maxBytes: number) {
-    super(413, "Payload Too Large", { maxBytes });
+    super(413, englishHttpMessage("payloadTooLarge"), { maxBytes }, { key: "payloadTooLarge" });
   }
 }
 
@@ -66,14 +82,14 @@ export class TooManyRequestsError extends HttpError {
     /** Extra response headers, for example `RateLimit-*` from {@link rateLimit}. */
     readonly headers?: Readonly<Record<string, string>>,
   ) {
-    super(429, "Too Many Requests");
+    super(429, englishHttpMessage("tooManyRequests"), undefined, { key: "tooManyRequests" });
   }
 }
 
 /**
  * Request body failed model validation (generated DTO binding + `@Validator`
  * rules on the DTO). The error handler renders it as 400 with the full list
- * of validation problems.
+ * of validation problems, each in the application language.
  */
 export class ModelValidationError extends BadRequestError {
   constructor(readonly errors: readonly ModelValidationIssue[], title = "Validation failed") {
@@ -82,6 +98,15 @@ export class ModelValidationError extends BadRequestError {
       errors.map((error) => ({ property: error.property, message: error.message, code: error.code })),
     );
   }
+
+  override readonly localized: LocalizedMessage = { key: "validationFailed" };
+}
+
+/** A 400 the framework writes itself: English text plus the key to translate it. */
+export function frameworkBadRequest(key: HttpMessageKey, params?: MessageParams, details?: unknown): BadRequestError {
+  return Object.assign(new BadRequestError(englishHttpMessage(key, params), details), {
+    localized: params === undefined ? { key } : { key, params },
+  }) as BadRequestError;
 }
 
 /**

package/core/http/Errors/messages.ts

@@ -0,0 +1,158 @@
+/** Placeholder values of a message template: `{name}` -> `params.name`. */
+export type MessageParams = Readonly<Record<string, unknown>>;
+
+/**
+ * Turns a message key and its parameters into text in the application
+ * language; `undefined` keeps the English text the error was created with.
+ * `runApp` builds it from its `language` and `messages` options.
+ */
+export type Localize = (key: string, params: MessageParams) => string | undefined;
+
+/** A message key and parameters carried by an error, rendered at the response. */
+export interface LocalizedMessage {
+  readonly key: string;
+  readonly params?: MessageParams;
+}
+
+/** Keys of the texts the HTTP layer writes itself. */
+export type HttpMessageKey =
+  | "badRequest"
+  | "unauthorized"
+  | "forbidden"
+  | "notFound"
+  | "methodNotAllowed"
+  | "conflict"
+  | "gone"
+  | "preconditionFailed"
+  | "payloadTooLarge"
+  | "unsupportedMediaType"
+  | "unprocessableContent"
+  | "locked"
+  | "tooManyRequests"
+  | "clientError"
+  | "internalServerError"
+  | "badGateway"
+  | "serviceUnavailable"
+  | "gatewayTimeout"
+  | "serverError"
+  | "malformedPath"
+  | "unsupportedApiVersion"
+  | "malformedJson"
+  | "malformedForm"
+  | "bodyNotObject"
+  | "bodyTooDeep"
+  | "bodyTooComplex"
+  | "bodyCyclic"
+  | "missingParameter"
+  | "invalidParameter"
+  | "invalidListQuery";
+
+export const EN_HTTP_MESSAGES: Readonly<Record<HttpMessageKey, string>> = Object.freeze({
+  badRequest: "Bad Request",
+  unauthorized: "Unauthorized",
+  forbidden: "Forbidden",
+  notFound: "Not Found",
+  methodNotAllowed: "Method Not Allowed",
+  conflict: "Conflict",
+  gone: "Gone",
+  preconditionFailed: "Precondition Failed",
+  payloadTooLarge: "Payload Too Large",
+  unsupportedMediaType: "Unsupported Media Type: expected {expected}",
+  unprocessableContent: "Unprocessable Content",
+  locked: "Locked",
+  tooManyRequests: "Too Many Requests",
+  clientError: "Client Error",
+  internalServerError: "Internal Server Error",
+  badGateway: "Bad Gateway",
+  serviceUnavailable: "Service Unavailable",
+  gatewayTimeout: "Gateway Timeout",
+  serverError: "Server Error",
+  malformedPath: "Malformed request path",
+  unsupportedApiVersion: "Unsupported API version",
+  malformedJson: "Malformed JSON in request body",
+  malformedForm: "Malformed form data in request body",
+  bodyNotObject: "Request body must be a JSON object",
+  bodyTooDeep: "Request body is too deeply nested",
+  bodyTooComplex: "Request body is too complex",
+  bodyCyclic: "Request body must be acyclic JSON",
+  missingParameter: 'Missing required {kind} parameter "{name}"',
+  invalidParameter: 'Parameter "{name}" must be of type {type}, got: "{value}"',
+  invalidListQuery: "Invalid list query",
+});
+
+export const RU_HTTP_MESSAGES: Readonly<Record<HttpMessageKey, string>> = Object.freeze({
+  badRequest: "Некорректный запрос",
+  unauthorized: "Требуется аутентификация",
+  forbidden: "Доступ запрещён",
+  notFound: "Не найдено",
+  methodNotAllowed: "Метод не поддерживается",
+  conflict: "Конфликт",
+  gone: "Ресурс удалён",
+  preconditionFailed: "Предусловие не выполнено",
+  payloadTooLarge: "Слишком большой запрос",
+  unsupportedMediaType: "Неподдерживаемый тип содержимого: ожидается {expected}",
+  unprocessableContent: "Невозможно обработать данные",
+  locked: "Ресурс заблокирован",
+  tooManyRequests: "Слишком много запросов",
+  clientError: "Ошибка в запросе",
+  internalServerError: "Внутренняя ошибка сервера",
+  badGateway: "Ошибка внешнего сервиса",
+  serviceUnavailable: "Сервис недоступен",
+  gatewayTimeout: "Внешний сервис не ответил вовремя",
+  serverError: "Ошибка сервера",
+  malformedPath: "Некорректный путь запроса",
+  unsupportedApiVersion: "Неподдерживаемая версия API",
+  malformedJson: "Тело запроса — некорректный JSON",
+  malformedForm: "Некорректные данные формы в теле запроса",
+  bodyNotObject: "Тело запроса должно быть JSON-объектом",
+  bodyTooDeep: "Слишком глубокая вложенность в теле запроса",
+  bodyTooComplex: "Тело запроса слишком сложное",
+  bodyCyclic: "Тело запроса не должно содержать циклов",
+  missingParameter: 'Не передан обязательный параметр "{name}"',
+  invalidParameter: 'Параметр "{name}": ожидается {type}, получено: "{value}"',
+  invalidListQuery: "Некорректные параметры списка",
+});
+
+/** Reason-phrase keys of the statuses the error handler writes for unexpected errors. */
+export const STATUS_MESSAGE_KEYS: Readonly<Record<number, HttpMessageKey>> = Object.freeze({
+  400: "badRequest", 401: "unauthorized", 403: "forbidden", 404: "notFound", 405: "methodNotAllowed",
+  409: "conflict", 410: "gone", 412: "preconditionFailed", 413: "payloadTooLarge", 415: "unsupportedMediaType",
+  422: "unprocessableContent", 423: "locked", 429: "tooManyRequests", 500: "internalServerError",
+  502: "badGateway", 503: "serviceUnavailable", 504: "gatewayTimeout",
+});
+
+/** Parameters whose value is a type name, translated through `typeName.<name>` keys. */
+const TYPE_PARAMS = new Set(["expected", "actual", "type"]);
+
+/**
+ * Substitutes `{name}` placeholders. Unknown placeholders stay as they are.
+ * With `lookup`, a type name in `expected`/`actual`/`type` is replaced by the
+ * `typeName.<name>` text when the catalog has one ("number" -> "число").
+ */
+export function formatMessage(template: string, params: MessageParams, lookup?: (key: string) => string | undefined): string {
+  return template.replace(/\{(\w+)\}/g, (placeholder, name: string) => {
+    if (!Object.prototype.hasOwnProperty.call(params, name) || params[name] === undefined) return placeholder;
+    const value = params[name];
+    if (lookup !== undefined && TYPE_PARAMS.has(name) && typeof value === "string") {
+      const typeName = lookup(`typeName.${value}`);
+      if (typeName !== undefined) return typeName;
+    }
+    return stringifyParam(value);
+  });
+}
+
+function stringifyParam(value: unknown): string {
+  if (typeof value === "object" && value !== null && !(value instanceof RegExp)) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+
+/** English text of a framework message, used when the app sets no language. */
+export function englishHttpMessage(key: HttpMessageKey, params: MessageParams = {}): string {
+  return formatMessage(EN_HTTP_MESSAGES[key], params);
+}

package/core/http/HttpContext/HttpContext.ts

@@ -1,5 +1,5 @@
 import type { ServiceScope } from "../../di";
-import { BadRequestError, PayloadTooLargeError } from "../Errors/HttpError";
+import { PayloadTooLargeError, frameworkBadRequest } from "../Errors/HttpError";
 import { ResponseBuilder } from "./ResponseBuilder";
 import type { ModelValidator } from "../Binding/modelValidator";
 
@@ -75,7 +75,7 @@ export class HttpContext {
       try {
         return JSON.parse(text) as T;
       } catch {
-        throw new BadRequestError("Malformed JSON in request body");
+        throw frameworkBadRequest("malformedJson");
       }
     });
     return this.bodyPromise as Promise<T>;
@@ -94,7 +94,7 @@ export class HttpContext {
         if (error instanceof PayloadTooLargeError) {
           throw error;
         }
-        throw new BadRequestError("Malformed form data in request body");
+        throw frameworkBadRequest("malformedForm");
       }) as ReturnType<Request["formData"]>;
   }
 

package/core/http/HttpServer.ts

@@ -22,6 +22,7 @@ import { HTTP_ERROR_HOOK, ROUTE_MIDDLEWARE_COMPOSER, SERVER_MIDDLEWARE, sortByOr
 import type { HealthEndpointOptions, RouteMiddlewareComposer, HttpModuleOptions, HttpServerOptions } from "./options";
 import { WEBSOCKET_UPGRADE, type WebSocketUpgrade } from "./WebSocketUpgrade";
 import { HttpSetupError } from "./Errors/HttpError";
+import { EN_HTTP_MESSAGES, formatMessage, type HttpMessageKey, type MessageParams } from "./Errors/messages";
 import { getModelValidator, type ModelValidator } from "./Binding/modelValidator";
 
 const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
@@ -166,6 +167,7 @@ export class HttpServer implements HostedService {
       errorHandler({
         exposeDetails,
         ...(errorLogger ? { logger: errorLogger } : {}),
+        ...(this.options.localize ? { localize: this.options.localize } : {}),
         ...this.options.errorHandler,
         onUnexpectedError: this.collectErrorHook(),
       }),
@@ -384,13 +386,23 @@ export class HttpServer implements HostedService {
     return request.method === "HEAD" ? stripBody(response) : response;
   }
 
+  /** A response text the server writes itself, in the application language. */
+  private text(key: HttpMessageKey, params: MessageParams = {}): string {
+    const english = formatMessage(EN_HTTP_MESSAGES[key], params);
+    try {
+      return this.options.localize?.(key, params) ?? english;
+    } catch {
+      return english;
+    }
+  }
+
   private transportError(error: unknown): Response {
     try {
       console.error("[http] transport failed:", redactSensitive(error));
     } catch {
       // Best-effort diagnostics only.
     }
-    const response = json(500, { error: "Internal Server Error" });
+    const response = json(500, { error: this.text("internalServerError") });
     if (this.options.securityHeaders !== false) {
       applySecurityHeaders(response, this.options.securityHeaders ?? {});
     }
@@ -434,9 +446,9 @@ export class HttpServer implements HostedService {
     if (!segments) {
       if (this.maxBodyBytes !== undefined && exceedsBodyLimit(request, this.maxBodyBytes)) {
         return this.runShortCircuit(request, url, clientIp, () =>
-          json(413, { error: "Payload Too Large", details: { maxBytes: this.maxBodyBytes } }));
+          json(413, { error: this.text("payloadTooLarge"), details: { maxBytes: this.maxBodyBytes } }));
       }
-      return this.runShortCircuit(request, url, clientIp, () => json(400, { error: "Malformed request path" }));
+      return this.runShortCircuit(request, url, clientIp, () => json(400, { error: this.text("malformedPath") }));
     }
 
     const match = this.router!.match(request.method, segments, this.readVersion(request, url));
@@ -445,18 +457,18 @@ export class HttpServer implements HostedService {
       : this.maxBodyBytes;
     if (effectiveMaxBodyBytes !== undefined && exceedsBodyLimit(request, effectiveMaxBodyBytes)) {
       return this.runShortCircuit(request, url, clientIp, () =>
-        json(413, { error: "Payload Too Large", details: { maxBytes: effectiveMaxBodyBytes } }));
+        json(413, { error: this.text("payloadTooLarge"), details: { maxBytes: effectiveMaxBodyBytes } }));
     }
     if (match.kind === "not-found") {
-      return this.runShortCircuit(request, url, clientIp, () => json(404, { error: "Not Found" }));
+      return this.runShortCircuit(request, url, clientIp, () => json(404, { error: this.text("notFound") }));
     }
     if (match.kind === "method-not-allowed") {
       return this.runShortCircuit(request, url, clientIp, () =>
-        json(405, { error: "Method Not Allowed" }, { allow: match.allow.join(", ") }));
+        json(405, { error: this.text("methodNotAllowed") }, { allow: match.allow.join(", ") }));
     }
     if (match.kind === "unsupported-version") {
       return this.runShortCircuit(request, url, clientIp, () =>
-        json(400, { error: "Unsupported API version", details: { supported: match.supported } }));
+        json(400, { error: this.text("unsupportedApiVersion"), details: { supported: match.supported } }));
     }
 
     const scope = this.provider.createScope();
@@ -475,7 +487,7 @@ export class HttpServer implements HostedService {
       await runPipeline(match.action.chain, ctx);
       // The error boundary always sets a response on failure; an empty
       // response here means no middleware produced one.
-      const response = this.prepareClientResponse(ctx.response ?? json(404, { error: "Not Found" }), request);
+      const response = this.prepareClientResponse(ctx.response ?? json(404, { error: this.text("notFound") }), request);
       if (request.method === "HEAD") return stripBody(response);
       if (!response.body) return response;
       this.trackResponse(holdResponseScope(response, request.signal, () =>
@@ -520,7 +532,7 @@ export class HttpServer implements HostedService {
     let scopeTransferred = false;
     try {
       await runPipeline([...this.shortCircuitChain, terminal], ctx);
-      const response = this.prepareClientResponse(ctx.response ?? json(500, { error: "Internal Server Error" }), request);
+      const response = this.prepareClientResponse(ctx.response ?? json(500, { error: this.text("internalServerError") }), request);
       if (request.method === "HEAD") return stripBody(response);
       if (!response.body) return response;
       this.trackResponse(holdResponseScope(response, request.signal, () =>

package/core/http/Middleware/errorHandler.ts

@@ -2,7 +2,8 @@ import { REQUEST_ID_STATE_KEY, type Logger } from "../../kernel";
 import { redactSensitive, redactSensitiveText } from "../../../library/redaction";
 import { HttpClientError, HttpErrorCode } from "../../../library/http-client/errors";
 import type { HttpContext } from "../HttpContext/HttpContext";
-import { HttpError } from "../Errors/HttpError";
+import { HttpError, ModelValidationError } from "../Errors/HttpError";
+import { EN_HTTP_MESSAGES, STATUS_MESSAGE_KEYS, type HttpMessageKey, type Localize } from "../Errors/messages";
 import { upstreamFailure } from "../Errors/upstreamFailure";
 import type { HttpMiddleware } from "./types";
 
@@ -33,6 +34,13 @@ export interface ErrorHandlerOptions {
    * passes the application `LOGGER`; without either, `console.error` is used.
    */
   logger?: Logger;
+  /**
+   * Renders framework texts (`Not Found`, validation messages, …) in the
+   * application language; `runApp` builds it from `language` and `messages`.
+   * Without it the texts stay English. Messages an application passes to an
+   * error itself are never changed.
+   */
+  localize?: Localize;
 }
 
 function jsonResponse(status: number, body: unknown, extraHeaders?: readonly [string, string][]): Response {
@@ -103,6 +111,7 @@ function safelyReportUnexpected(
  */
 export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware {
   const log = resolveErrorLog(options);
+  const text = textRenderer(options.localize);
   return async (ctx, next) => {
     try {
       await next();
@@ -125,14 +134,23 @@ export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware
         if (headers !== undefined) {
           extra.push(...Object.entries(headers));
         }
+        const message = error.localized === undefined ? error.message : text(error.localized.key, error.localized.params, error.message);
+        const details = error instanceof ModelValidationError
+          ? error.errors.map((issue) => ({
+              property: issue.property,
+              message: issue.params === undefined || issue.code === undefined ? issue.message : text(issue.code, issue.params, issue.message),
+              code: issue.code,
+            }))
+          : error.details;
         ctx.response = safeJsonResponse(
           error.status,
-          error.details === undefined ? { error: error.message } : { error: error.message, details: error.details },
+          details === undefined ? { error: message } : { error: message, details },
           extra,
         );
         return;
       }
-      const [status, title] = unexpectedStatus(error, options.status);
+      const [status, key] = unexpectedStatus(error, options.status);
+      const title = text(key, {}, EN_HTTP_MESSAGES[key]);
       if (status >= 500) safelyReportUnexpected(options, log, ctx, error);
       ctx.response = options.exposeDetails
         ? safeJsonResponse(status, {
@@ -154,19 +172,27 @@ export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware
  * and stays 500, like everything else. Upstream details never reach the
  * client; the log keeps the full error.
  */
-const REASONS: Readonly<Record<number, string>> = {
-  400: "Bad Request", 404: "Not Found", 409: "Conflict", 410: "Gone", 412: "Precondition Failed", 422: "Unprocessable Content",
-  423: "Locked", 429: "Too Many Requests", 500: "Internal Server Error", 502: "Bad Gateway", 503: "Service Unavailable", 504: "Gateway Timeout",
-};
-
-function unexpectedStatus(error: unknown, mapper?: (error: unknown) => number | undefined): readonly [number, string] {
+function unexpectedStatus(error: unknown, mapper?: (error: unknown) => number | undefined): readonly [number, HttpMessageKey] {
   if (error instanceof HttpClientError && error.code !== undefined) {
-    return error.code === HttpErrorCode.Timeout ? [504, "Gateway Timeout"] : [502, "Bad Gateway"];
+    return error.code === HttpErrorCode.Timeout ? [504, "gatewayTimeout"] : [502, "badGateway"];
   }
   const upstream = upstreamFailure(error);
-  if (upstream !== undefined) return upstream === "timeout" ? [504, "Gateway Timeout"] : [502, "Bad Gateway"];
+  if (upstream !== undefined) return upstream === "timeout" ? [504, "gatewayTimeout"] : [502, "badGateway"];
   let mapped: number | undefined;
   try { mapped = mapper?.(error); } catch { mapped = undefined; }
-  if (mapped !== undefined && Number.isInteger(mapped) && mapped >= 400 && mapped <= 599) return [mapped, REASONS[mapped] ?? (mapped >= 500 ? "Server Error" : "Client Error")];
-  return [500, "Internal Server Error"];
+  if (mapped !== undefined && Number.isInteger(mapped) && mapped >= 400 && mapped <= 599) return [mapped, STATUS_MESSAGE_KEYS[mapped] ?? (mapped >= 500 ? "serverError" : "clientError")];
+  return [500, "internalServerError"];
+}
+
+/** Text of a message key in the application language, or the English fallback. */
+function textRenderer(localize: Localize | undefined): (key: string, params: Readonly<Record<string, unknown>> | undefined, fallback: string) => string {
+  if (localize === undefined) return (_key, _params, fallback) => fallback;
+  return (key, params, fallback) => {
+    try {
+      return localize(key, params ?? {}) ?? fallback;
+    } catch {
+      // A broken catalog must not turn an error response into a 500.
+      return fallback;
+    }
+  };
 }

package/core/http/index.ts

@@ -141,4 +141,5 @@ export {
   UnauthorizedError,
   UnsupportedMediaTypeError,
 } from "./Errors/HttpError";
+export { EN_HTTP_MESSAGES, RU_HTTP_MESSAGES, type HttpMessageKey, type Localize, type LocalizedMessage } from "./Errors/messages";
 export { markUpstreamFailure, upstreamFailure, type UpstreamFailure } from "./Errors/upstreamFailure";

package/core/http/options.ts

@@ -2,6 +2,7 @@ import type { Class } from "../di";
 import type { AccessLogOptions } from "./Middleware/accessLog";
 import type { CorsOptions } from "./Middleware/cors";
 import type { ErrorHandlerOptions } from "./Middleware/errorHandler";
+import type { Localize } from "./Errors/messages";
 import type { SecurityHeadersOptions } from "./Middleware/securityHeaders";
 import type { HttpMiddleware } from "./Middleware/types";
 import type { ActionMeta, ControllerMeta } from "./Decorators/metadata";
@@ -58,6 +59,12 @@ export interface HttpModuleOptions {
   readonly inspectableRedirects?: boolean;
   /** Request-model validator captured by this HTTP server instance. */
   readonly validator?: ModelValidator;
+  /**
+   * Renders framework response texts in the application language. `runApp`
+   * sets it from its `language` and `messages` options; without it the
+   * texts are English.
+   */
+  readonly localize?: Localize;
   /**
    * Modules providing the controllers' dependencies. Controllers live inside
    * the returned HttpModule, so their dependencies must be visible to it:

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.100.6" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.100.7" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/validation/MessageRegistry.ts

@@ -5,7 +5,7 @@
 export type MessageParams = Readonly<Record<string, unknown>>;
 
 /** Built-in default messages (English). */
-const BUILT_IN: Readonly<Record<string, string>> = {
+export const EN_VALIDATION_MESSAGES: Readonly<Record<string, string>> = Object.freeze({
   validationFailed: "Validation failed",
   invalid: 'Field "{property}" is invalid ({code})',
   required: 'Field "{property}" is required',
@@ -39,30 +39,36 @@ const BUILT_IN: Readonly<Record<string, string>> = {
   customError: 'Check of field "{property}" failed with an error: {error}',
   asyncCustomInSyncCall:
     'Field "{property}": an async custom check is not supported by synchronous validate(); use validateAsync()',
-};
+  unknownField: 'Field "{property}" is forbidden or not declared by the model.',
+});
+const BUILT_IN = EN_VALIDATION_MESSAGES;
 
 /**
- * Russian texts for every built-in code. Apply once at startup:
+ * Russian texts for every built-in code. An application gets them with
+ * `runApp(AppModule, { language: "ru" })`; outside an application:
  * `MessageRegistry.setDefaults(RU_VALIDATION_MESSAGES)`.
+ *
+ * Numbers stand after a dash ("минимальная длина — 5"), so no template needs
+ * a plural form. `typeName.*` keys translate the type names in `type`.
  */
 export const RU_VALIDATION_MESSAGES: Readonly<Record<string, string>> = Object.freeze({
   validationFailed: "Проверка данных не пройдена",
   invalid: 'Поле "{property}" не прошло проверку ({code})',
   required: 'Поле "{property}" обязательно для заполнения',
   notEmpty: 'Поле "{property}" не должно быть пустым',
-  minLength: 'Поле "{property}" должно содержать не менее {min} символов',
-  maxLength: 'Поле "{property}" должно содержать не более {max} символов',
-  length: 'Поле "{property}" должно содержать от {min} до {max} символов',
-  minItems: 'Поле "{property}" должно содержать не менее {min} элементов',
-  maxItems: 'Поле "{property}" должно содержать не более {max} элементов',
-  itemCount: 'Поле "{property}" должно содержать от {min} до {max} элементов',
+  minLength: 'Поле "{property}": минимальная длина — {min}',
+  maxLength: 'Поле "{property}": максимальная длина — {max}',
+  length: 'Поле "{property}": длина — от {min} до {max}',
+  minItems: 'Поле "{property}": минимум элементов — {min}',
+  maxItems: 'Поле "{property}": максимум элементов — {max}',
+  itemCount: 'Поле "{property}": количество элементов — от {min} до {max}',
   contains: 'Поле "{property}" должно содержать "{contains}"',
   notContains: 'Поле "{property}" не должно содержать "{contains}"',
   pattern: 'Поле "{property}" не соответствует формату {pattern}',
   email: 'Поле "{property}" должно быть корректным email-адресом',
   url: 'Поле "{property}" должно быть корректным URL',
   uuid: 'Поле "{property}" должно быть корректным UUID',
-  type: 'Поле "{property}" должно иметь тип {expected}, получено: {actual}',
+  type: 'Поле "{property}": ожидается {expected}, получено: {actual}',
   min: 'Поле "{property}" должно быть не меньше {min}',
   max: 'Поле "{property}" должно быть не больше {max}',
   range: 'Поле "{property}" должно быть в диапазоне от {min} до {max}',
@@ -79,6 +85,15 @@ export const RU_VALIDATION_MESSAGES: Readonly<Record<string, string>> = Object.f
   customError: 'Проверка поля "{property}" завершилась ошибкой: {error}',
   asyncCustomInSyncCall:
     'Поле "{property}": асинхронная custom-проверка не поддерживается синхронным validate(), используйте validateAsync()',
+  unknownField: 'Поле "{property}" запрещено или не объявлено в модели',
+  "typeName.string": "строка",
+  "typeName.number": "число",
+  "typeName.int": "целое число",
+  "typeName.boolean": "логическое значение",
+  "typeName.bool": "логическое значение",
+  "typeName.array": "массив",
+  "typeName.object": "объект",
+  "typeName.JSON object or array": "объект или массив",
 });
 
 /**
@@ -92,6 +107,8 @@ export const RU_VALIDATION_MESSAGES: Readonly<Record<string, string>> = Object.f
 export class MessageRegistry {
   /** Current global templates: a copy of the built-in ones + overrides. */
   private static defaults: Record<string, string> = { ...BUILT_IN };
+  /** Only the templates set through {@link setDefaults}. */
+  private static overrides: Record<string, string> = {};
 
   /**
    * Overrides global messages for error codes.
@@ -107,6 +124,7 @@ export class MessageRegistry {
       const template = messages[code];
       if (typeof template === "string") {
         MessageRegistry.defaults[code] = template;
+        MessageRegistry.overrides[code] = template;
       }
     }
   }
@@ -114,6 +132,12 @@ export class MessageRegistry {
   /** Resets all global overrides to the built-in messages. */
   static reset(): void {
     MessageRegistry.defaults = { ...BUILT_IN };
+    MessageRegistry.overrides = {};
+  }
+
+  /** A template set through {@link setDefaults}, or `undefined`. */
+  static override(code: string): string | undefined {
+    return Object.prototype.hasOwnProperty.call(MessageRegistry.overrides, code) ? MessageRegistry.overrides[code] : undefined;
   }
 
   /**
@@ -137,6 +161,11 @@ export class MessageRegistry {
       if (!Object.prototype.hasOwnProperty.call(params, key) || params[key] === undefined) {
         return placeholder;
       }
+      const value = params[key];
+      if ((key === "expected" || key === "actual") && typeof value === "string") {
+        const typeName = MessageRegistry.defaults[`typeName.${value}`];
+        if (typeName !== undefined && Object.prototype.hasOwnProperty.call(MessageRegistry.defaults, `typeName.${value}`)) return typeName;
+      }
       return MessageRegistry.stringify(params[key]);
     });
   }

package/library/validation/README.md

@@ -47,7 +47,7 @@ More scenarios (complex conditions, async, nested objects) are in
 | `ValidationResult.ts` | the outcome: `isValid`, `errors`, `getErrorsFor`, `hasErrorsFor` |
 | `RuleEngine.ts` | the engine: one pass over the plan, sync/async, nested, cycle protection |
 | `RuleCompiler.ts` | compiles class rules into a plan + WeakMap cache (RegExp, enum Set) |
-| `MessageRegistry.ts` | message templates, placeholders, priority local > global > built-in; built-in texts are English, `RU_VALIDATION_MESSAGES` is a Russian set for `setDefaults` |
+| `MessageRegistry.ts` | message templates, placeholders, priority local > global > built-in; built-in texts are English, `RU_VALIDATION_MESSAGES` is a Russian set for `setDefaults` and `runApp({ language: "ru" })` |
 | `metadata.ts` | stores rules through `context.metadata` / `Symbol.metadata` |
 | `types/ValidatorOptions.ts` | all decorator options |
 | `types/ValidationCode.ts` | error codes |

package/library/validation/RuleEngine.ts

@@ -381,7 +381,7 @@ export class RuleEngine {
         params[key] = extra[key];
       }
     }
-    errors.push(new ValidationError(path, value, MessageRegistry.format(code, o.message, params), code));
+    errors.push(new ValidationError(path, value, MessageRegistry.format(code, o.message, params), code, o.message === undefined ? params : undefined));
   }
 
   private static failType(errors: ValidationError[], path: string, value: unknown, o: ValidatorOptions, expected: string): void {

package/library/validation/SPEC.md

@@ -444,7 +444,13 @@ so a valid object pays no allocations for it.
 
 Template priority: **the decorator's local `message` > global (`setDefaultMessages`) >
 built-in**. A string returned from `custom` wins over all of them.
-Built-in messages are English; `RU_VALIDATION_MESSAGES` is a Russian set for `setDefaultMessages`.
+Built-in messages are English (`EN_VALIDATION_MESSAGES`); `RU_VALIDATION_MESSAGES` is a Russian set for `setDefaultMessages`.
+An HTTP application picks the language with `runApp({ language: "ru", messages })`: each
+`ValidationError` built from a template carries `params`, and the HTTP error handler
+re-renders it in the application language (a rule's own `message` has no `params` and
+stays as is). Priority there: `messages` > `setDefaultMessages` > the language set > English.
+Russian templates put numbers after a dash ("минимальная длина — 5"), so no plural forms are
+needed; `typeName.*` keys translate the type names in the `type` message.
 
 ```ts
 // Globally (once at application start):

package/library/validation/ValidationError.ts

@@ -22,12 +22,16 @@ export class ValidationError {
    * @param value Actual field value at check time.
    * @param message Human-readable message (placeholders already substituted).
    * @param code Machine-readable rule code, for example `"required"` or `"minLength"`.
+   * @param params Placeholder values when `message` comes from the template of
+   *   `code`: an application re-renders it in its language. The engine leaves
+   *   it out for a rule's own `message`.
    */
   constructor(
     readonly property: string,
     readonly value: unknown,
     readonly message: string,
     readonly code?: string,
+    readonly params?: Readonly<Record<string, unknown>>,
   ) {}
 
   /** Short `property: message` form, handy for logs. */

package/library/validation/index.ts

@@ -11,6 +11,6 @@ export { Validator } from "./Validator";
 export { modelValidatorAdapter } from "./modelValidatorAdapter";
 export { ValidationError } from "./ValidationError";
 export { ValidationResult } from "./ValidationResult";
-export { MessageRegistry, RU_VALIDATION_MESSAGES, type MessageParams } from "./MessageRegistry";
+export { EN_VALIDATION_MESSAGES, MessageRegistry, RU_VALIDATION_MESSAGES, type MessageParams } from "./MessageRegistry";
 export { ValidationCodes, type ValidationCode } from "./types/ValidationCode";
 export type { CustomOutcome, CustomValidator, ValidationTypeHint, ValidatorOptions } from "./types/ValidatorOptions";

package/library/validation/modelValidatorAdapter.ts

@@ -7,6 +7,7 @@ interface AdapterValidationIssue {
   readonly property: string;
   readonly message: string;
   readonly code?: string;
+  readonly params?: Readonly<Record<string, unknown>>;
 }
 
 /**
@@ -38,14 +39,11 @@ export const modelValidatorAdapter = {
     return toAdapterResult(instance, await Validator.validateAsync(instance));
   },
 
-  /** A JSON value of the wrong type, in the current `MessageRegistry` language. */
-  typeMismatchMessage(property: string, expected: string, actual: string): string {
-    return MessageRegistry.format("type", undefined, { property, expected, actual });
+  /** A binder message in the current `MessageRegistry` language. */
+  message(code: string, params: Readonly<Record<string, unknown>>): string {
+    return MessageRegistry.format(code, undefined, params);
   },
 
-  failureTitle(): string {
-    return MessageRegistry.format("validationFailed", undefined, {});
-  },
 };
 
 interface AdapterValidationResult {
@@ -59,6 +57,7 @@ function toAdapterResult(instance: object, result: ValidationResult): AdapterVal
       property: error.property,
       message: error.message,
       code: error.code,
+      ...(error.params === undefined ? {} : { params: error.params }),
     }));
     errors.push(...nestedInstanceErrors);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.100.6",
+  "version": "0.100.7",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",