bazis 0.99.6 → 0.100.0

package/library/terminal/screen.ts

@@ -0,0 +1,358 @@
+import { detectLanguage, type Language } from "./language";
+import { messages, type Messages } from "./messages";
+import { detectTerminal, Paint, PALETTE, colorAt, padEnd, padStart, widthOf, type TerminalStyle } from "./style";
+
+/** Where a screen writes: `process.stdout`, `process.stderr` or a test buffer. */
+export interface ScreenOutput {
+  write(text: string): unknown;
+  readonly isTTY?: boolean;
+  readonly columns?: number;
+}
+
+export type Status = "ok" | "fail" | "skip" | "warn" | "up" | "down" | "wait" | "info";
+
+/** One problem of a failure screen: what, where, why and how to fix it. */
+export interface Problem {
+  /** Short class of the problem: `CONFIG`, `INFRA`, `DI`, `TIMEOUT`, `CODEGEN`. */
+  readonly tag: string;
+  /** Key, connection or `file:line`. */
+  readonly where: string;
+  readonly cause: string;
+  readonly fixes?: readonly string[];
+  readonly frame?: CodeFrame;
+  /** Stable error code, such as `BAZIS_DI_DEPENDENCY_UNKNOWN`. */
+  readonly code?: string;
+  readonly declaredIn?: string;
+  /** Extra lines (for example a stack) printed after the fixes. */
+  readonly details?: readonly string[];
+}
+
+/** Lines around an error position, with the marked column range. */
+export interface CodeFrame {
+  /** `[lineNumber, text]` pairs in order. */
+  readonly lines: readonly (readonly [number, string])[];
+  readonly line: number;
+  /** 1-based start column and length of the marked span. */
+  readonly column?: number;
+  readonly length?: number;
+  readonly label?: string;
+}
+
+export interface TreeRow {
+  readonly text: string;
+  /** Rows nested under this one. */
+  readonly children?: readonly TreeRow[];
+}
+
+const LOGO = Object.freeze(["█▀▀▄ ▄▀▀▄ ▀▀▀█ ▀█▀ █▀▀▀", "█▀▀▄ █▀▀█ ▄▀▀  ░█░ ▀▀▀█", "▀▀▀  ▀  ▀ ▀▀▀▀ ▀▀▀ ▀▀▀▀"]);
+const SPINNER = Object.freeze(["◜", "◠", "◝", "◞", "◡", "◟"]);
+const STEP_LABEL = 16;
+const TIME = 8;
+
+/** Mode badges of the logo: the command that runs. */
+export const MODE = Object.freeze({
+  dev: [PALETTE.yellow, PALETTE.orange] as readonly string[],
+  test: ["#4cc9f0", "#7b61ff"] as readonly string[],
+  build: ["#00f0ff", "#3dff7a"] as readonly string[],
+  prod: [PALETTE.green, PALETTE.lime] as readonly string[],
+  new: ["#ff2ee6", "#7b61ff"] as readonly string[],
+  gen: ["#c77dff", "#ff2ee6"] as readonly string[],
+  codegen: ["#00f0ff", "#c77dff"] as readonly string[],
+});
+
+/**
+ * One terminal screen: the logo header, sections, steps with a spinner,
+ * success and failure banners, panels and problem boxes. The same calls give
+ * plain text without colour or animation when the output is not a terminal,
+ * so CI logs keep the structure.
+ */
+export class Screen {
+  readonly paint: Paint;
+  readonly t: Messages;
+  readonly style: TerminalStyle;
+  readonly language: Language;
+  private readonly badgeWidth: number;
+
+  constructor(readonly output: ScreenOutput = process.stdout, options: { style?: TerminalStyle; language?: Language } = {}) {
+    this.style = options.style ?? detectTerminal(output);
+    this.language = options.language ?? detectLanguage();
+    this.t = messages(this.language);
+    this.paint = new Paint(this.style);
+    this.badgeWidth = Math.max(...Object.values(this.t.badge).map((label) => widthOf(label))) + 2;
+  }
+
+  get width(): number {
+    return this.style.width;
+  }
+
+  line(text = ""): void {
+    this.output.write(`${text}\n`);
+  }
+
+  // ── text helpers ──────────────────────────────────────────────────────────
+
+  fg(color: string, text: string): string { return this.paint.fg(color, text); }
+  bold(text: string): string { return this.paint.bold(text); }
+  strong(text: string, color: string = PALETTE.white): string { return this.paint.bold(this.paint.fg(color, text)); }
+  muted(text: string): string { return this.paint.fg(PALETTE.muted, text); }
+  faint(text: string): string { return this.paint.fg(PALETTE.faint, text); }
+  text(text: string): string { return this.paint.fg(PALETTE.text, text); }
+  /** Code, a variable or a command inside a sentence. */
+  code(text: string): string { return this.paint.bold(this.paint.fg(PALETTE.yellow, text)); }
+  link(url: string): string { return this.paint.link(url, PALETTE.link); }
+  get dot(): string { return this.faint(" · "); }
+  /** `12 files`: the number stands out. */
+  num(value: number | string, word: string, color: string = PALETTE.white): string {
+    return `${this.strong(String(value), color)} ${this.muted(word)}`;
+  }
+  kv(key: string, value: string): string { return `${this.muted(key)} ${value}`; }
+  cause(text: string): string { return `${this.strong("✖", PALETTE.red)}  ${this.text(text)}`; }
+  fix(text: string): string { return `${this.strong("➜", PALETTE.lime)}  ${text}`; }
+
+  badge(status: Status): string {
+    const label = this.t.badge[status];
+    const text = this.bold(padEnd(` ${label}`, this.badgeWidth));
+    if (!this.style.color) return `[${padEnd(label, this.badgeWidth - 2)}]`;
+    switch (status) {
+      case "ok": return this.paint.bg(PALETTE.green, this.paint.fg(PALETTE.ink, text));
+      case "fail": return this.paint.bg(PALETTE.red, this.paint.fg(PALETTE.white, text));
+      case "skip": return this.paint.bg("#2a3350", this.paint.fg(PALETTE.muted, text));
+      case "warn": return this.paint.bg("#b45309", this.paint.fg(PALETTE.white, text));
+      case "up": return this.paint.bg("#0e3b2a", this.paint.fg(PALETTE.lime, text));
+      case "down": return this.paint.bg("#4a0f1d", this.paint.fg(PALETTE.red, text));
+      case "wait": return this.paint.bg("#4a3a0f", this.paint.fg(PALETTE.orange, text));
+      case "info": return this.paint.bg("#1b2a4a", this.paint.fg(PALETTE.link, text));
+    }
+  }
+
+  // ── blocks ────────────────────────────────────────────────────────────────
+
+  /** The logo with a mode badge and three lines of facts next to it. */
+  header(mode: string, stops: readonly string[], meta: readonly string[]): void {
+    this.line();
+    const badge = this.style.color ? this.paint.gradientBg(`  ${mode.toUpperCase()}  `, stops, PALETTE.ink) : `[${mode.toUpperCase()}]`;
+    for (let index = 0; index < LOGO.length; index += 1) {
+      const logo = this.style.color ? this.paint.gradient(LOGO[index]!, PALETTE.brand) : LOGO[index]!;
+      const lead = index === 0 ? `${badge}  ` : "";
+      this.line(`  ${logo}    ${lead}${meta[index] ?? ""}`);
+    }
+    this.line();
+  }
+
+  /** `── TITLE ────── aside`; red when the stage failed. */
+  section(title: string, aside = "", failed = false): void {
+    const label = ` ${title} `;
+    const rule = "─".repeat(Math.max(4, this.width - widthOf(label) - widthOf(aside) - 6));
+    const lead = failed ? this.fg(PALETTE.red, "──") : this.paint.gradient("──", PALETTE.brand);
+    const tail = this.style.color ? this.paint.gradient(rule, failed ? ["#5c1a2a", "#26304d"] : [PALETTE.faint, "#26304d"]) : rule;
+    this.line(`  ${lead}${this.strong(label, failed ? PALETTE.red : PALETTE.white)}${tail}${aside ? ` ${aside}` : ""}`);
+  }
+
+  /** A finished step: badge, label, details and the time on the right. */
+  step(status: Status, label: string, detail = "", time = ""): void {
+    const color = status === "fail" ? PALETTE.red : status === "skip" ? PALETTE.muted : PALETTE.white;
+    const width = Math.max(10, this.width - STEP_LABEL - TIME - this.badgeWidth - 4);
+    this.line(`  ${this.badge(status)}  ${padEnd(this.strong(label, color), STEP_LABEL)}${padEnd(detail, width)}${padStart(this.muted(time), TIME)}`);
+  }
+
+  /**
+   * A step in progress: a spinner on a terminal, nothing elsewhere. The
+   * returned function clears the line; the caller then prints the result
+   * with {@link step}.
+   */
+  progress(label: string, note?: () => string): () => void {
+    if (!this.style.animate) return () => undefined;
+    let frame = 0;
+    const draw = () => {
+      const spinner = this.paint.bg(PALETTE.panel, this.strong(` ${SPINNER[frame % SPINNER.length]} `, colorAt(PALETTE.brand, (frame % 12) / 11)));
+      frame += 1;
+      this.output.write(`\r\x1b[2K  ${spinner}   ${this.strong(label, PALETTE.text)}${this.muted(" …")}${note ? ` ${note()}` : ""}`);
+    };
+    draw();
+    const timer = setInterval(draw, 80);
+    timer.unref?.();
+    let stopped = false;
+    return () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      this.output.write("\r\x1b[2K");
+    };
+  }
+
+  /** Runs `work` with a spinner and prints its step line. */
+  async run<T>(label: string, work: () => Promise<T>, done: (result: T, ms: number) => { status?: Status; detail?: string } = () => ({})): Promise<T> {
+    const started = performance.now();
+    const stop = this.progress(label);
+    try {
+      const result = await work();
+      stop();
+      const ms = performance.now() - started;
+      const shown = done(result, ms);
+      this.step(shown.status ?? "ok", label, shown.detail ?? "", formatDuration(ms));
+      return result;
+    } catch (error) {
+      stop();
+      this.step("fail", label, "", formatDuration(performance.now() - started));
+      throw error;
+    }
+  }
+
+  /** Rows under a step, drawn as a tree: `├─`, `│`, `└─`. */
+  tree(rows: readonly TreeRow[], indent = 9): void {
+    const walk = (items: readonly TreeRow[], prefix: string) => {
+      items.forEach((row, index) => {
+        const last = index === items.length - 1;
+        this.line(`${" ".repeat(indent)}${this.faint(prefix + (last ? "└─ " : "├─ "))}${row.text}`);
+        if (row.children?.length) walk(row.children, prefix + (last ? "   " : "│  "));
+      });
+    };
+    walk(rows, "");
+  }
+
+  /** A full-width gradient banner: SUCCESS / FAILED and what it means. */
+  banner(kind: "success" | "failed", text: string): void {
+    const word = kind === "success" ? this.t.banner.success : this.t.banner.failed;
+    const icon = kind === "success" ? "✔" : "✖";
+    const content = `  ${icon}  ${word}   ${text}`;
+    if (!this.style.color) {
+      const rule = "═".repeat(this.width);
+      this.line(`  ${rule}`);
+      this.line(`  ${content}`);
+      this.line(`  ${rule}`);
+      this.line();
+      return;
+    }
+    const stops = kind === "success" ? PALETTE.success : PALETTE.failure;
+    const ink = kind === "success" ? PALETTE.ink : PALETTE.white;
+    const width = Math.max(this.width, widthOf(content) + 2);
+    this.line(`  ${this.paint.gradientBg(" ".repeat(width), stops, ink)}`);
+    this.line(`  ${this.paint.gradientBg(padEnd(content, width), stops, ink)}`);
+    this.line(`  ${this.paint.gradientBg(" ".repeat(width), stops, ink)}`);
+    this.line();
+  }
+
+  /** A rounded box with gradient borders: links and next steps. */
+  panel(rows: readonly string[]): void {
+    const width = this.width - 2;
+    const stops = ["#00f0ff", "#7b61ff"];
+    const border = (text: string) => this.style.color ? this.paint.gradient(text, stops) : text;
+    this.line(`  ${border(`╭${"─".repeat(width)}╮`)}`);
+    for (const row of rows) {
+      this.line(`  ${this.fg("#00f0ff", "│")} ${padEnd(row, width - 1)}${this.fg("#7b61ff", "│")}`);
+    }
+    this.line(`  ${border(`╰${"─".repeat(width)}╯`)}`);
+  }
+
+  /** `➜  Label     value` row of a {@link panel}. */
+  panelRow(label: string, value: string): string {
+    return `${this.strong("➜", PALETTE.lime)}  ${padEnd(this.strong(label), 11)}${value}`;
+  }
+
+  /** One problem box: `1/2 CONFIG db.password`, the cause, a code frame, the fixes. */
+  problem(index: number, total: number, problem: Problem): void {
+    const width = this.width - 2;
+    const stops = [PALETTE.red, PALETTE.pink];
+    const counter = this.style.color ? this.paint.bg(PALETTE.red, this.strong(` ${index}/${total} `)) : `${index}/${total}`;
+    const tag = this.style.color ? this.paint.bg("#4a0f1d", this.strong(` ${problem.tag} `, PALETTE.red)) : `[${problem.tag}]`;
+    const title = ` ${counter} ${tag} ${this.strong(problem.where)} `;
+    const fill = "─".repeat(Math.max(2, width - widthOf(title) - 1));
+    this.line(`  ${this.fg(PALETTE.red, "╭─")}${title}${this.style.color ? this.paint.gradient(fill, stops) : fill}${this.fg(PALETTE.pink, "╮")}`);
+    const rows: string[] = [];
+    for (const [lineIndex, causeLine] of problem.cause.split("\n").entries()) rows.push(lineIndex === 0 ? this.cause(causeLine) : `   ${this.text(causeLine)}`);
+    if (problem.frame) rows.push("", ...this.frame(problem.frame));
+    if (problem.fixes?.length) rows.push("", ...problem.fixes.map((fix) => this.fix(fix)));
+    if (problem.declaredIn) rows.push(`${this.faint(`   ${this.t.common.declaredIn}`)} ${this.text(problem.declaredIn)}`);
+    if (problem.code) rows.push(`${this.faint(`   ${this.t.common.code}`)} ${this.muted(problem.code)}`);
+    if (problem.details?.length) rows.push("", ...problem.details.map((detail) => this.faint(detail)));
+    for (const row of rows) {
+      for (const piece of wrap(row, width - 1)) this.line(`  ${this.fg(PALETTE.red, "│")} ${padEnd(piece, width - 1)}${this.fg(PALETTE.pink, "│")}`);
+    }
+    this.line(`  ${this.style.color ? this.paint.gradient(`╰${"─".repeat(width)}╯`, stops) : `╰${"─".repeat(width)}╯`}`);
+  }
+
+  /** Every problem with a blank line between them. */
+  problems(problems: readonly Problem[]): void {
+    problems.forEach((problem, index) => {
+      this.problem(index + 1, problems.length, problem);
+      this.line();
+    });
+  }
+
+  frame(frame: CodeFrame): string[] {
+    const numberWidth = Math.max(...frame.lines.map(([number]) => String(number).length));
+    const rows: string[] = [];
+    for (const [number, text] of frame.lines) {
+      const gutter = `${padStart(String(number), numberWidth + 2)} │`;
+      if (number !== frame.line) {
+        rows.push(`${this.faint(gutter)} ${this.muted(text)}`);
+        continue;
+      }
+      const column = frame.column ?? 0;
+      const length = Math.max(1, frame.length ?? 1);
+      const marked = column > 0
+        ? `${this.text(text.slice(0, column - 1))}${this.paint.bg("#4a0f1d", this.strong(text.slice(column - 1, column - 1 + length), PALETTE.red))}${this.text(text.slice(column - 1 + length))}`
+        : this.text(text);
+      rows.push(`${this.strong(gutter, PALETTE.red)} ${marked}`);
+      if (column > 0) {
+        rows.push(`${this.faint(`${" ".repeat(numberWidth + 2)} │`)} ${this.fg(PALETTE.red, `${" ".repeat(column - 1)}${"^".repeat(length)}${frame.label ? ` ${frame.label}` : ""}`)}`);
+      }
+    }
+    return rows;
+  }
+
+  warning(text: string): void {
+    this.line(`  ${this.badge("warn")}  ${this.text(text)}`);
+  }
+
+  footer(text: string): void {
+    this.line(`  ${this.muted(text)}`);
+    this.line();
+  }
+
+  /** A horizontal bar of a timing chart. */
+  bar(label: string, value: number, total: number, color: string, suffix: string): void {
+    const size = 46;
+    const filled = total > 0 ? Math.max(1, Math.round((value / total) * size)) : 1;
+    const bar = this.style.color ? `${this.fg(color, "█".repeat(filled))}${this.fg(PALETTE.panel, "█".repeat(size - filled))}` : `${"#".repeat(filled)}${".".repeat(size - filled)}`;
+    this.line(`     ${padEnd(this.muted(label), 18)}${bar} ${padStart(this.text(suffix), 9)}`);
+  }
+
+  /** `─── logs ─────` before the application's own output. */
+  divider(title: string): void {
+    this.line(`  ${this.faint(`─── ${title} ${"─".repeat(Math.max(4, this.width - widthOf(title) - 5))}`)}`);
+  }
+}
+
+/** `0.4 ms`, `41 ms`, `1.2 s`. */
+export function formatDuration(ms: number): string {
+  if (ms < 1) return `${ms.toFixed(1)} ms`;
+  if (ms < 1000) return `${Math.round(ms)} ms`;
+  return `${(ms / 1000).toFixed(1)} s`;
+}
+
+/** `512 B`, `48 MB`. */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+/** Splits a styled line by visible width, keeping words together where possible. */
+function wrap(text: string, width: number): string[] {
+  if (widthOf(text) <= width) return [text];
+  const words = text.split(" ");
+  const lines: string[] = [];
+  let current = "";
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (current && widthOf(candidate) > width) {
+      lines.push(current);
+      current = `   ${word}`;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}

package/library/terminal/style.ts

@@ -0,0 +1,143 @@
+/**
+ * Terminal capabilities and colour helpers. Every helper degrades to plain
+ * text when colour is off, so the same rendering code serves a terminal, a CI
+ * log and a file.
+ */
+
+export interface TerminalStyle {
+  /** 24-bit colour escapes. */
+  readonly color: boolean;
+  /** Spinners and in-place redraws: only on an interactive terminal. */
+  readonly animate: boolean;
+  /** Clickable OSC 8 links. */
+  readonly links: boolean;
+  /** Columns for full-width lines (clamped to 72..110). */
+  readonly width: number;
+}
+
+interface StreamLike {
+  readonly isTTY?: boolean;
+  readonly columns?: number;
+}
+
+/**
+ * Colour on an interactive terminal; `NO_COLOR` turns it off and
+ * `FORCE_COLOR` (anything but `0`) turns it on, as in other CLIs. CI logs and
+ * redirected output get plain text without animation.
+ */
+export function detectTerminal(stream: StreamLike = process.stdout, env: NodeJS.ProcessEnv = process.env): TerminalStyle {
+  const interactive = stream.isTTY === true && env.TERM !== "dumb" && !env.CI;
+  const forced = env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "0";
+  const color = env.NO_COLOR === undefined && (forced || interactive);
+  const columns = typeof stream.columns === "number" && stream.columns > 0 ? stream.columns - 4 : 96;
+  return Object.freeze({ color, animate: interactive, links: color && interactive, width: Math.max(72, Math.min(110, columns)) });
+}
+
+export const PLAIN: TerminalStyle = Object.freeze({ color: false, animate: false, links: false, width: 96 });
+
+type Rgb = readonly [number, number, number];
+
+function rgb(hex: string): Rgb {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
+function mix(a: string, b: string, t: number): string {
+  const [r1, g1, b1] = rgb(a), [r2, g2, b2] = rgb(b);
+  const channel = (x: number, y: number) => Math.round(x + (y - x) * t).toString(16).padStart(2, "0");
+  return `#${channel(r1, r2)}${channel(g1, g2)}${channel(b1, b2)}`;
+}
+
+/** Colour at position `t` (0..1) of a gradient through `stops`. */
+export function colorAt(stops: readonly string[], t: number): string {
+  if (stops.length === 1) return stops[0]!;
+  const segment = Math.min(stops.length - 2, Math.floor(t * (stops.length - 1)));
+  return mix(stops[segment]!, stops[segment + 1]!, t * (stops.length - 1) - segment);
+}
+
+const ANSI = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\/g;
+
+/** Text as the terminal shows it: escapes removed. */
+export function plain(text: string): string {
+  return text.replace(ANSI, "");
+}
+
+/** Visible width in columns. */
+export function widthOf(text: string): number {
+  return [...plain(text)].length;
+}
+
+export function padEnd(text: string, width: number): string {
+  return text + " ".repeat(Math.max(0, width - widthOf(text)));
+}
+
+export function padStart(text: string, width: number): string {
+  return " ".repeat(Math.max(0, width - widthOf(text))) + text;
+}
+
+/** Colour primitives bound to one terminal: no-ops when colour is off. */
+export class Paint {
+  constructor(readonly style: TerminalStyle) {}
+
+  fg(hex: string, text: string): string {
+    if (!this.style.color) return text;
+    const [r, g, b] = rgb(hex);
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+  }
+
+  bg(hex: string, text: string): string {
+    if (!this.style.color) return text;
+    const [r, g, b] = rgb(hex);
+    return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+  }
+
+  bold(text: string): string {
+    return this.style.color ? `\x1b[1m${text}\x1b[22m` : text;
+  }
+
+  gradient(text: string, stops: readonly string[]): string {
+    if (!this.style.color) return text;
+    const chars = [...text];
+    return chars.map((char, index) => this.fg(colorAt(stops, chars.length === 1 ? 0 : index / (chars.length - 1)), char)).join("");
+  }
+
+  gradientBg(text: string, stops: readonly string[], ink: string): string {
+    if (!this.style.color) return text;
+    const chars = [...text];
+    return chars.map((char, index) => this.bg(colorAt(stops, chars.length === 1 ? 0 : index / (chars.length - 1)), this.fg(ink, this.bold(char)))).join("");
+  }
+
+  /** A clickable link where the terminal supports it, otherwise the URL itself. */
+  link(url: string, color: string): string {
+    const text = this.bold(this.fg(color, url));
+    if (!this.style.links) return text;
+    return `\x1b]8;;${url}\x1b\\\x1b[4m${text}\x1b[24m\x1b]8;;\x1b\\`;
+  }
+}
+
+/** The bazis palette. */
+export const PALETTE = Object.freeze({
+  brand: ["#00f0ff", "#7b61ff", "#ff2ee6"] as readonly string[],
+  success: ["#00c853", "#3dff7a", "#00f0ff"] as readonly string[],
+  failure: ["#ff2e5b", "#ff3d8b", "#ff2ee6"] as readonly string[],
+  lime: "#3dff7a",
+  green: "#00c853",
+  yellow: "#ffe14d",
+  orange: "#ff9f1c",
+  red: "#ff2e5b",
+  pink: "#ff2ee6",
+  white: "#ffffff",
+  text: "#f1f5f9",
+  muted: "#8b9bb4",
+  faint: "#4b5a78",
+  ink: "#0b1020",
+  panel: "#1b2140",
+  link: "#5ce1ff",
+  route: "#ffd60a",
+  service: "#c77dff",
+  table: "#00d4ff",
+  job: "#ff8c42",
+  tool: "#ff4fd8",
+  export: "#7ee8fa",
+  methods: { GET: "#3dff7a", POST: "#ffd60a", PUT: "#4cc9f0", PATCH: "#c77dff", DELETE: "#ff2e5b", HEAD: "#8b9bb4", OPTIONS: "#8b9bb4" } as Readonly<Record<string, string>>,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.99.6",
+  "version": "0.100.0",
   "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",
@@ -50,6 +50,7 @@
     "./library/openapi": "./library/openapi/index.ts",
     "./library/orm": "./library/orm/index.ts",
     "./library/redaction": "./library/redaction/index.ts",
+    "./library/terminal": "./library/terminal/index.ts",
     "./library/ui": "./library/ui/index.ts",
     "./library/validation": "./library/validation/index.ts"
   },