bazis 0.100.6 → 0.100.8

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/di/errors/InvalidProviderError.ts

@@ -1,9 +1,10 @@
 import { DiError } from "./DiError";
 
 export class InvalidProviderError extends DiError {
-  public constructor(tokenName: string) {
+  /** `message` replaces the default text when the caller knows more (the module and position). */
+  public constructor(tokenName: string, message?: string) {
     super(
-      `Provider for "${tokenName}" has unknown shape: expected one of useClass/useFactory/useValue.`,
+      message ?? `Provider for "${tokenName}" has unknown shape: expected one of useClass/useFactory/useValue.`,
     );
   }
 }

package/core/di/errors/ScopedServiceFromRootError.ts

@@ -4,6 +4,7 @@ import { DiError } from "./DiError";
 
 export class ScopedServiceFromRootError extends DiError {
   public constructor(token: Token<unknown>) {
-    super(`Cannot resolve scoped service "${tokenToDebugName(token)}" from root provider.`);
+    const name = tokenToDebugName(token);
+    super(`Cannot resolve scoped service "${name}" from root provider. A scoped service lives in a request or a scope: create one with provider.createScope(), resolve "${name}" from it and dispose the scope when done.`);
   }
 }

package/core/di/internal/GraphValidator.ts

@@ -64,8 +64,12 @@ export class GraphValidator {
     issues: Set<string>,
   ): void {
     if (registrationPath.has(registration.id)) {
-      const cyclePath = [...tokenPath, registration.token].map((token) => tokenToDebugName(token)).join(" -> ");
-      issues.add(`Cycle detected: ${cyclePath}`);
+      // One cycle is reached from each of its members: report it once, as the cycle itself.
+      const start = tokenPath.indexOf(registration.token);
+      const members = (start >= 0 ? tokenPath.slice(start) : tokenPath).map((token) => tokenToDebugName(token));
+      const first = members.indexOf([...members].sort()[0] as string);
+      const canonical = [...members.slice(first), ...members.slice(0, first)];
+      issues.add(`Cycle detected: ${[...canonical, canonical[0]].join(" -> ")}`);
       return;
     }
 

package/core/di/module/createContainer.ts

@@ -4,7 +4,7 @@ import { HOSTED_SERVICE, HOSTED_SERVICE_HEALTH, type HostedService } from "../ex
 import { SERVICE_PROVIDER, SERVICE_PROVIDER_BY_TYPE } from "../extensions/service-provider-token";
 import { isClassProvider, ProviderDefinition, type Provider } from "../provider";
 import { getClassDeps } from "../internal/classDeps";
-import { DiError, ModuleEncapsulationError } from "../errors";
+import { DiError, InvalidProviderError, ModuleEncapsulationError } from "../errors";
 import { OpenGenericRegistration } from "../internal/OpenGenericRegistration";
 import { tokenToDebugName, type Class } from "../token";
 import type { BuildServiceProviderOptions } from "../types";
@@ -133,6 +133,7 @@ export function createContainer(rootModule: BazisModuleRef, options?: CreateCont
     const providers = moduleRef.providers;
     if (providers) {
       for (let index = 0; index < providers.length; index += 1) {
+        assertProviderDefinition(providers[index], record.name, index);
         collection.add(providers[index] as ProviderDefinition);
       }
     }
@@ -311,3 +312,19 @@ function normalizeLateGeneratedClassDeps(definition: ProviderDefinition): Provid
   const normalizedProvider = { ...provider, deps: generatedDeps } as Provider<unknown>;
   return new ProviderDefinition(normalizedProvider, definition.lifetime, definition.key);
 }
+
+/**
+ * A module lists registrations made by singleton/scoped/transient/…; a raw
+ * `{ provide: X }` object used to crash later with a bare TypeError.
+ */
+function assertProviderDefinition(value: unknown, moduleName: string, index: number): void {
+  const provider = (value as { provider?: unknown } | null | undefined)?.provider;
+  if (typeof provider === "object" && provider !== null && "provide" in provider) return;
+  const provide = (value as { provide?: unknown } | null | undefined)?.provide;
+  const name = typeof provide === "function" ? provide.name : typeof provide === "string" ? provide : String(provide ?? value);
+  throw new InvalidProviderError(
+    name,
+    `Module "${moduleName}": providers[${index}] is not a provider registration${provide === undefined ? "" : ` ({ provide: ${name} })`}. `
+      + `Register it with singleton(${name}), scoped(${name}), transient(${name}), singletonValue(TOKEN, value) or singletonFactory(TOKEN, [deps], factory).`,
+  );
+}

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,6 @@
+import { KernelError } from "../../kernel";
 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 +12,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 +83,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,15 +99,20 @@ 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;
 }
 
 /**
  * Misconfigured routes/controllers (duplicate route, bad template, missing
- * @Controller). Thrown at startup, never at request time — fail fast.
+ * @Controller). Thrown at startup, never at request time — fail fast. A
+ * KernelError: the start reports it as a configuration error of the code.
  */
-export class HttpSetupError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "HttpSetupError";
-  }
-}
+export class HttpSetupError extends KernelError {}