bazis 0.136.0 → 0.138.0

package/core/access/check/can.ts

@@ -1,4 +1,5 @@
 import type { AuthorizeCheck, AuthorizeContext } from "../../http";
+import type { PermissionKey } from "../catalog/permissions";
 import type { AccessObject } from "../contracts/types";
 import { IAccess } from "./IAccess.service";
 
@@ -13,7 +14,7 @@ import { IAccess } from "./IAccess.service";
  * @Post() create(ctx: HttpContext) { … }
  * ```
  */
-export function can(permission: string, objectOf?: (ctx: AuthorizeContext) => AccessObject | Promise<AccessObject>): AuthorizeCheck {
+export function can(permission: PermissionKey, objectOf?: (ctx: AuthorizeContext) => AccessObject | Promise<AccessObject>): AuthorizeCheck {
   return async (ctx) => {
     const access = await ctx.services.resolve(IAccess).for(ctx);
     return await access.can(permission, objectOf === undefined ? undefined : await objectOf(ctx));

package/core/access/index.ts

@@ -5,9 +5,19 @@
  */
 import "./catalog/moduleFields";
 import "./generated/deps";
+import type { accessPermissions } from "./Access.module";
+import type { PermissionsOf } from "./catalog/permissions";
+
+/**
+ * The permissions the application declares, by key: what `can`, `access.can`,
+ * `access.filter` and `defineRoles` accept. Nobody writes it by hand: `bazis codegen`
+ * fills it from `permissions` of the application's modules
+ * (`src/generated/bazis/permissions.ts`), a framework pack from its own.
+ */
+export interface BazisPermissions extends PermissionsOf<typeof accessPermissions> {}
 
 export { AccessModule } from "./Access.module";
-export { definePermissions, type AttributeSpec, type PermissionDeclarations, type PermissionSpec, type ScopeSource } from "./catalog/permissions";
+export { definePermissions, type AttributeSpec, type OwnPermissionKey, type PermissionDeclarations, type PermissionKey, type PermissionsOf, type PermissionSpec, type ScopeSource } from "./catalog/permissions";
 export { IAccessCatalog } from "./catalog/IAccessCatalog.service";
 export type { DeclaredRole, OwnedPermission, OwnedReferenceKind } from "./catalog/AccessCatalog";
 export { IAccess } from "./check/IAccess.service";

package/core/access/roles/roles.ts

@@ -1,3 +1,4 @@
+import type { OwnPermissionKey, PermissionKey } from "../catalog/permissions";
 import type { Condition, Grant, GrantFields, Scope } from "../contracts/types";
 
 /**
@@ -5,9 +6,10 @@ import type { Condition, Grant, GrantFields, Scope } from "../contracts/types";
  * grant with conditions.
  */
 export type RoleGrant =
-  | string
+  | PermissionKey
+  | `${OwnPermissionKey}:own`
   | {
-      readonly permission: string;
+      readonly permission: PermissionKey;
       readonly scopes?: "all" | readonly Scope[];
       readonly where?: Condition;
       readonly fields?: GrantFields;

package/core/access/testing/index.ts

@@ -2,13 +2,18 @@
  * Test helpers of access (ACCESS-001 §8): a rights system whose grants are set
  * right in the test.
  */
+import { singletonValue, type ProviderDefinition } from "../../di";
 import { PRINCIPAL_STATE_KEY, type AuthorizeContext, type RequestPrincipal } from "../../http";
 import { AccessPolicy, type ScopePrincipals } from "../contracts/AccessPolicy";
 import type { AccessSubject, Grants, Scope } from "../contracts/types";
 
 export interface StaticAccessOptions {
-  /** Subject → permission → grants; a permission not listed gives nothing. */
-  readonly grants: Readonly<Record<string, Readonly<Record<string, Grants>>>>;
+  /** Subject → permission → grants; a permission not listed gives {@link otherwise}. */
+  readonly grants?: Readonly<Record<string, Readonly<Record<string, Grants>>>>;
+  /** What a permission not listed in `grants` gives: nothing by default, `"all"` to allow everything. */
+  readonly otherwise?: Grants;
+  /** Who a request without a signed-in principal is; by default nobody, and the request is refused. */
+  readonly anonymous?: string;
   /** Subject → the owner ids meaning it; by default `sub` after the last `:`. */
   readonly owners?: Readonly<Record<string, readonly string[]>>;
   /** Subject → its addressees in every partition; by default `user:<owner id>`. */
@@ -32,11 +37,12 @@ export class StaticAccessPolicy extends AccessPolicy {
 
   subject(ctx: AuthorizeContext): AccessSubject | undefined {
     const sub = (ctx.state.get(PRINCIPAL_STATE_KEY) as RequestPrincipal | undefined)?.subject;
-    return sub === undefined || sub === "" ? undefined : { sub };
+    if (sub !== undefined && sub !== "") return { sub };
+    return this.options.anonymous === undefined ? undefined : { sub: this.options.anonymous };
   }
 
   grants(subject: AccessSubject, permission: string): Grants {
-    return this.options.grants[subject.sub]?.[permission] ?? [];
+    return this.options.grants?.[subject.sub]?.[permission] ?? this.options.otherwise ?? [];
   }
 
   ownerIds(subject: AccessSubject): readonly string[] {
@@ -49,6 +55,22 @@ export class StaticAccessPolicy extends AccessPolicy {
   }
 }
 
+/**
+ * A rights system that allows everything, for a test that is not about rights:
+ * every subject has every permission in every partition.
+ *
+ * ```ts
+ * const app = await startTestApp(OrdersApp, { overrides: [allowAll()] });
+ * ```
+ *
+ * Requests still need a signed-in principal; `allowAll({ anonymous: "test" })`
+ * also lets in a request without one, as the subject `test`. `grants` narrows
+ * single subjects: `allowAll({ grants: { "user:2": { "orders.delete": [] } } })`.
+ */
+export function allowAll(options: Omit<StaticAccessOptions, "otherwise"> = {}): ProviderDefinition {
+  return singletonValue(AccessPolicy, new StaticAccessPolicy({ ...options, otherwise: "all" }));
+}
+
 function ownerId(sub: string): string {
   return sub.slice(sub.lastIndexOf(":") + 1);
 }

package/core/agent/ToolRunner.ts

@@ -1,4 +1,5 @@
-import { DI, DiError, Global, HOSTED_SERVICE, Module, registerModuleMetadataExpander, SERVICE_PROVIDER, type BazisModuleMetadata, type ServiceProvider } from "../di";
+import { DiError, Global, HOSTED_SERVICE, Module, registerModuleMetadataExpander, SERVICE_PROVIDER, type BazisModuleMetadata, type ServiceProvider } from "../di";
+import { DI } from "../di/lowLevel";
 import { LOGGER } from "../kernel/logging/Logger";
 import { modelValidatorAdapter } from "../../library/validation";
 import { AgentRegistry, type ToolDefinition } from "./AgentRegistry";
@@ -42,6 +43,11 @@ export class ToolRunner {
     this.executor = new AgentToolExecutor(services, this.catalog, { schemaValidator: modelValidatorAdapter, ...executorOptions }, logger);
   }
 
+  /** Every Tool of the application, whoever may call it. */
+  listTools(): readonly ToolDefinition[] {
+    return this.catalog.listTools();
+  }
+
   /** A view of the Tools this caller may run. `"agent"` is refused: agents run through `AgentRuntime`. */
   as(caller: string): BoundToolRunner {
     let id: string;

package/core/agent/defineTool.ts

@@ -0,0 +1,109 @@
+import { ServiceProvider, type Class } from "../di";
+import { registerFrameworkClassDeps } from "../di/module/autoDeps";
+import { Tool } from "./decorators/Tool";
+import { AgentSetupError } from "./errors";
+import { toolMetadataOf, type ToolOptions } from "./metadata";
+import type { AgentToolExecutionContext } from "./AgentToolExecutor";
+
+declare const TOOL_TYPES: unique symbol;
+
+/**
+ * A Tool made by {@link defineTool}. It stands in `@Module({ tools })` next to
+ * the classes with `@Tool`, and a process names it by reference.
+ */
+export type DefinedTool<I = unknown, O = unknown> = Class<object> & {
+  /** The name it is called by: `orm.order.find`. */
+  readonly toolName: string;
+  /** Only for the types: what `execute` takes and gives back. */
+  readonly [TOOL_TYPES]?: { readonly input: I; readonly output: O };
+};
+
+/** Several made Tools under the names their factory gave them: `orderTools.find`. */
+export type ToolSet<K extends string = string> = { readonly [P in K]: DefinedTool };
+
+/** What `defineTool` takes: what `@Tool` takes, without the classes of input and output, and the work itself. */
+export interface DefinedToolOptions<I = unknown, O = unknown> extends Omit<ToolOptions, "input" | "output"> {
+  /**
+   * Does the work. `services` is the scope of the call: `services.resolve(OrdersDbContext)`.
+   * The input comes as the caller sent it: check it here.
+   */
+  execute(input: I, context: AgentToolExecutionContext, services: ServiceProvider): O | Promise<O>;
+}
+
+const DEFINED = new WeakSet<object>();
+
+/**
+ * A Tool without a class: for Tools made by a function, when their number and
+ * names are known only from its arguments. A Tool written by hand is a class
+ * with `@Tool`.
+ *
+ * ```ts
+ * export function exportTools(formats: readonly string[]): ToolSet {
+ *   return Object.fromEntries(formats.map((format) => [format, defineTool({
+ *     name: `reports.export.${format}`,
+ *     description: `Exports a report as ${format}.`,
+ *     sideEffect: "read",
+ *     callers: ["workflow"],
+ *     inputSchema: { type: "object", properties: { reportId: { type: "string" } }, required: ["reportId"] },
+ *     execute: (input: { reportId: string }, _context, services) => services.resolve(ReportService).export(input.reportId, format),
+ *   })]));
+ * }
+ *
+ * @Module({ tools: [SendReportTool, exportTools(["pdf", "csv"])] })
+ * ```
+ */
+export function defineTool<I = unknown, O = unknown>(definition: DefinedToolOptions<I, O>): DefinedTool<I, O> {
+  if (definition === null || typeof definition !== "object" || typeof definition.execute !== "function") {
+    throw new AgentSetupError("defineTool takes the description of a Tool with its execute(input, context, services).");
+  }
+  const { execute, ...options } = definition;
+
+  @Tool(options)
+  class MadeTool {
+    static readonly toolName = String(options.name).trim();
+
+    constructor(private readonly services: ServiceProvider) {}
+
+    execute(input: unknown, context: AgentToolExecutionContext): unknown {
+      return execute(input as I, context, this.services);
+    }
+  }
+
+  // The class is made here, so codegen never sees its constructor.
+  registerFrameworkClassDeps([[MadeTool, [ServiceProvider]]]);
+  DEFINED.add(MadeTool);
+  Object.defineProperty(MadeTool, "name", { value: `Tool(${MadeTool.toolName})` });
+  return MadeTool as unknown as DefinedTool<I, O>;
+}
+
+/** Whether a value came from {@link defineTool}. */
+export function isDefinedTool(value: unknown): value is DefinedTool {
+  return typeof value === "function" && DEFINED.has(value);
+}
+
+/**
+ * @internal The Tools a module lists in `tools`: classes with `@Tool`, made Tools
+ * and sets of them, as one list of classes.
+ */
+export function moduleToolsOf(value: unknown): readonly Class<object>[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) throw new AgentSetupError("tools must be an array of classes with @Tool, Tools made by defineTool and sets of them.");
+  const out: Class<object>[] = [];
+  for (const entry of value) {
+    if (typeof entry === "function") {
+      out.push(entry as Class<object>);
+      continue;
+    }
+    const members = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? Object.entries(entry) : undefined;
+    if (members === undefined || members.length === 0 || members.some(([, member]) => !isDefinedTool(member))) {
+      throw new AgentSetupError("tools must list classes with @Tool, Tools made by defineTool and sets of them: an object in the list must hold only Tools made by defineTool.");
+    }
+    for (const [, member] of members) out.push(member as Class<object>);
+  }
+  return out;
+}
+
+/** The name a class with `@Tool` or a made Tool is called by; `undefined` for anything else. */
+export function toolNameOf(tool: unknown): string | undefined {
+  return typeof tool === "function" ? toolMetadataOf(tool as Class<object>)?.name : undefined;
+}

package/core/agent/index.ts

@@ -1,14 +1,16 @@
 import type { Class } from "../di";
 import { registerModuleDescriber } from "../kernel/report/moduleTree";
+import { moduleToolsOf, type DefinedTool, type ToolSet } from "./defineTool";
 import { toolMetadataOf } from "./metadata";
 
 // The module tree of the startup screen: `orders.summary · read`.
-registerModuleDescriber((metadata) => (metadata.tools ?? []).map((tool) => {
+registerModuleDescriber((metadata) => moduleToolsOf(metadata.tools).map((tool) => {
   const meta = toolMetadataOf(tool);
   return { kind: "tool" as const, text: meta === undefined ? tool.name : `${meta.name} · ${meta.sideEffect}` };
 }));
 
 export { Tool } from "./decorators/Tool";
+export { defineTool, isDefinedTool, toolNameOf, type DefinedTool, type DefinedToolOptions, type ToolSet } from "./defineTool";
 export { describeTool } from "./Tool.contract";
 export type {
   AgentToolHookKindV1, AgentToolHookRefV1, AgentToolRequiredHookRefV1, AgentToolHookRegistrationBaseV1,
@@ -149,8 +151,11 @@ export {
 // depend on program file order and silently stop merging in some projects.
 declare module "../di/module/types/BazisModule" {
   interface BazisModuleMetadata {
-    /** Tools agents may call: classes with `@Tool`. An agent definition names them in `toolNames`. */
-    readonly tools?: readonly Class<object>[];
+    /**
+     * The Tools of the module: classes with `@Tool`, Tools made by `defineTool`
+     * and sets of them (`ormEntityTools(...)`). An agent definition names them in `toolNames`.
+     */
+    readonly tools?: readonly (Class<object> | DefinedTool | ToolSet)[];
     readonly agentToolHooks?: readonly import("./AgentToolHooks").AgentToolHookRegistrationV1[];
   }
 }

package/core/agent/moduleContributions-v1.ts

@@ -11,6 +11,7 @@ import {
   type BazisModuleRef,
 } from "../di";
 import { AgentSetupError } from "./errors";
+import { moduleToolsOf } from "./defineTool";
 import { toolMetadataOf } from "./metadata";
 import type { AgentToolHookRegistrationV1 } from "./AgentToolHooks";
 
@@ -25,18 +26,10 @@ const HOOK_CHANNEL = createModuleOwnedProviderChannel<AgentOwnedHookContribution
 // Internal imports (including generatedRuntime's type-only AgentRegistry import)
 // must not depend on the public barrel having augmented DI's metadata interface.
 interface AgentModuleFields {
-  readonly tools?: readonly Class<object>[];
+  readonly tools?: readonly unknown[];
   readonly agentToolHooks?: readonly AgentToolHookRegistrationV1[];
 }
 
-function classValues(value: unknown, field: string): readonly Class<object>[] {
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "function")) {
-    throw new AgentSetupError(`${field} must be an array of classes.`);
-  }
-  return value as readonly Class<object>[];
-}
-
 export function assertAgentToolHookIdV1(id: unknown): asserts id is string {
   if (typeof id !== "string" || !/^[\x20-\x7e]{1,128}$/.test(id)) {
     throw new AgentSetupError("Agent Tool hook id must contain 1 to 128 printable ASCII characters.");
@@ -59,7 +52,7 @@ function assertHook(registration: AgentToolHookRegistrationV1): void {
 registerModuleOwnedProviderContributor((metadata: BazisModuleMetadata, context) => {
   const owner = metadata as BazisModuleRef;
   const fields = metadata as BazisModuleMetadata & AgentModuleFields;
-  for (const target of classValues(fields.tools, "tools")) {
+  for (const target of moduleToolsOf(fields.tools)) {
     const tool = toolMetadataOf(target);
     if (!tool) throw new AgentSetupError(`${target.name || "<anonymous class>"} is listed as a tool but is not decorated with @Tool(...).`);
     if (tool.callers.length === 0) {

package/core/agent/session/entities.ts

@@ -1,4 +1,4 @@
-import { Column, DbContext, Entity, Index, Key } from "../../../library/orm";
+import { Column, DbContext, Entity, Index, Key, Nullable } from "../../../library/orm";
 
 /** Immutable v1 schema. These tables are owned exclusively by AgentSessionDbContext. */
 @Entity({ table: "bazis_agent_sessions_v1" })
@@ -6,42 +6,42 @@ import { Column, DbContext, Entity, Index, Key } from "../../../library/orm";
 @Index(["sessionId"], { unique: true })
 export class AgentSessionRowV1 {
   @Key({ generated: false }) @Column({ type: "uuid" }) id = "";
-  @Column({ type: "uuid" }) sessionId = "";
-  @Column({ type: "uuid" }) invocationId = "";
-  @Column({ type: "text" }) createKey = "";
-  @Column({ type: "text" }) requestBinding = "";
-  @Column({ type: "text" }) ownerSubject = "";
-  @Column({ type: "text", nullable: true }) tenant?: string;
-  @Column({ type: "text" }) agentName = "";
-  @Column({ type: "text" }) implementationVersion = "";
-  @Column({ type: "text" }) bindingHash = "";
-  @Column({ type: "text" }) state = "created";
-  @Column({ type: "integer" }) revision = 0;
-  @Column({ type: "integer" }) steps = 0;
-  @Column({ type: "boolean" }) stopRequested = false;
-  @Column({ type: "integer" }) checkpointRevision = 0;
-  @Column({ type: "text", nullable: true }) ownerId?: string;
-  @Column({ type: "integer" }) ownerEpoch = 0;
-  @Column({ type: "datetime", nullable: true }) ownerLeaseUntil?: Date;
-  @Column({ type: "text", nullable: true }) runCommandId?: string;
-  @Column({ type: "datetime", nullable: true }) runDeadline?: Date;
-  @Column({ type: "integer" }) nextSequence = 1;
-  @Column({ type: "integer", nullable: true }) pendingIntentSequence?: number;
-  @Column({ type: "boolean" }) admissionReserved = false;
-  @Column({ type: "datetime" }) createdAt = new Date();
-  @Column({ type: "datetime" }) updatedAt = new Date();
+  @Nullable() @Column({ type: "uuid" }) sessionId = "";
+  @Nullable() @Column({ type: "uuid" }) invocationId = "";
+  @Nullable() @Column({ type: "text" }) createKey = "";
+  @Nullable() @Column({ type: "text" }) requestBinding = "";
+  @Nullable() @Column({ type: "text" }) ownerSubject = "";
+  @Nullable() @Column({ type: "text" }) tenant?: string;
+  @Nullable() @Column({ type: "text" }) agentName = "";
+  @Nullable() @Column({ type: "text" }) implementationVersion = "";
+  @Nullable() @Column({ type: "text" }) bindingHash = "";
+  @Nullable() @Column({ type: "text" }) state = "created";
+  @Nullable() @Column({ type: "integer" }) revision = 0;
+  @Nullable() @Column({ type: "integer" }) steps = 0;
+  @Nullable() @Column({ type: "boolean" }) stopRequested = false;
+  @Nullable() @Column({ type: "integer" }) checkpointRevision = 0;
+  @Nullable() @Column({ type: "text" }) ownerId?: string;
+  @Nullable() @Column({ type: "integer" }) ownerEpoch = 0;
+  @Nullable() @Column({ type: "datetime" }) ownerLeaseUntil?: Date;
+  @Nullable() @Column({ type: "text" }) runCommandId?: string;
+  @Nullable() @Column({ type: "datetime" }) runDeadline?: Date;
+  @Nullable() @Column({ type: "integer" }) nextSequence = 1;
+  @Nullable() @Column({ type: "integer" }) pendingIntentSequence?: number;
+  @Nullable() @Column({ type: "boolean" }) admissionReserved = false;
+  @Nullable() @Column({ type: "datetime" }) createdAt = new Date();
+  @Nullable() @Column({ type: "datetime" }) updatedAt = new Date();
 }
 
 @Entity({ table: "bazis_agent_session_checkpoints_v1" })
 @Index(["sessionId", "checkpointRevision"], { unique: true })
 export class AgentSessionCheckpointRowV1 {
   @Key({ generated: false }) @Column({ type: "uuid" }) id = "";
-  @Column({ type: "uuid" }) sessionId = "";
-  @Column({ type: "integer" }) checkpointRevision = 0;
-  @Column({ type: "text" }) bindingHash = "";
-  @Column({ type: "text" }) keyId = "";
-  @Column({ type: "text" }) ciphertext = "";
-  @Column({ type: "datetime" }) createdAt = new Date();
+  @Nullable() @Column({ type: "uuid" }) sessionId = "";
+  @Nullable() @Column({ type: "integer" }) checkpointRevision = 0;
+  @Nullable() @Column({ type: "text" }) bindingHash = "";
+  @Nullable() @Column({ type: "text" }) keyId = "";
+  @Nullable() @Column({ type: "text" }) ciphertext = "";
+  @Nullable() @Column({ type: "datetime" }) createdAt = new Date();
 }
 
 @Entity({ table: "bazis_agent_session_journal_v1" })
@@ -49,26 +49,26 @@ export class AgentSessionCheckpointRowV1 {
 @Index(["sessionId", "commandId"], { unique: false })
 export class AgentSessionJournalRowV1 {
   @Key({ generated: false }) @Column({ type: "uuid" }) id = "";
-  @Column({ type: "uuid" }) eventId = "";
-  @Column({ type: "uuid" }) sessionId = "";
-  @Column({ type: "integer" }) sequence = 0;
-  @Column({ type: "integer" }) aggregateRevision = 0;
-  @Column({ type: "text" }) kind = "";
-  @Column({ type: "text", nullable: true }) commandId?: string;
-  @Column({ type: "text" }) projectionJson = "{}";
-  @Column({ type: "text", nullable: true }) binding?: string;
-  @Column({ type: "datetime" }) occurredAt = new Date();
+  @Nullable() @Column({ type: "uuid" }) eventId = "";
+  @Nullable() @Column({ type: "uuid" }) sessionId = "";
+  @Nullable() @Column({ type: "integer" }) sequence = 0;
+  @Nullable() @Column({ type: "integer" }) aggregateRevision = 0;
+  @Nullable() @Column({ type: "text" }) kind = "";
+  @Nullable() @Column({ type: "text" }) commandId?: string;
+  @Nullable() @Column({ type: "text" }) projectionJson = "{}";
+  @Nullable() @Column({ type: "text" }) binding?: string;
+  @Nullable() @Column({ type: "datetime" }) occurredAt = new Date();
 }
 
 @Entity({ table: "bazis_agent_session_admission_v1" })
 @Index(["bucket"], { unique: true })
 export class AgentSessionAdmissionRowV1 {
   @Key({ generated: false }) @Column({ type: "uuid" }) id = "";
-  @Column({ type: "text" }) bucket = "";
-  @Column({ type: "text" }) configHash = "";
-  @Column({ type: "integer" }) maxActiveRuns = 8;
-  @Column({ type: "integer" }) activeReservations = 0;
-  @Column({ type: "datetime" }) updatedAt = new Date();
+  @Nullable() @Column({ type: "text" }) bucket = "";
+  @Nullable() @Column({ type: "text" }) configHash = "";
+  @Nullable() @Column({ type: "integer" }) maxActiveRuns = 8;
+  @Nullable() @Column({ type: "integer" }) activeReservations = 0;
+  @Nullable() @Column({ type: "datetime" }) updatedAt = new Date();
 }
 
 export class AgentSessionDbContext extends DbContext {

package/core/app/index.ts

@@ -1,6 +1,6 @@
 // Composition layer: the single application entry point. Depends on the kernel, HTTP, gRPC and
 // 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 { App, runApp, type AppClass, type AppOptions, type AppSettings } from "./runApp";
 export type { AppLanguage, AppMessages } from "./messages";
 export * from "./ui";

package/core/app/messages.ts

@@ -35,7 +35,7 @@ const CATALOGS: Readonly<Record<AppLanguage, Readonly<Record<string, string>>>>
  */
 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(", ")}.`);
+    throw new KernelError(`@App: 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>>;
@@ -62,9 +62,9 @@ export function createLanguages(option: AppLanguage | AppLanguageOptions = "en",
     return { negotiated: false, select: () => single };
   }
   const supported = [...new Set(option.supported)];
-  if (supported.length === 0) throw new KernelError("runApp: language.supported needs at least one language.");
+  if (supported.length === 0) throw new KernelError("@App: language.supported needs at least one language.");
   if (!supported.includes(option.default)) {
-    throw new KernelError(`runApp: language.default "${String(option.default)}" must be one of language.supported (${supported.join(", ")}).`);
+    throw new KernelError(`@App: language.default "${String(option.default)}" must be one of language.supported (${supported.join(", ")}).`);
   }
   const selected = new Map<string, SelectedLanguage>(supported.map((language) => [language, { language, localize: createLocalize(language, messages) }]));
   const fallback = selected.get(option.default)!;