@kernel.chat/kbot 3.36.0 → 3.38.0

package/README.md

@@ -19,7 +19,7 @@
 npm install -g @kernel.chat/kbot
 ```
 
-**Self-defending AI agent. 350+ tools. 26 agents. 20 providers. Forges new tools at runtime. Built-in cybersecurity suite. $0 local AI. MIT licensed.**
+**Self-defending AI agent. 384+ tools. 41 agents. 20 providers. Forges new tools at runtime. Built-in cybersecurity suite. $0 local AI. MIT licensed.**
 
 > **New: [The Kernel Stack](./KERNEL_STACK.md)** — the architecture behind kbot + Claude Code. Agentic, self-improving, compound AI. Read the manifesto.
 
@@ -27,6 +27,18 @@ npm install -g @kernel.chat/kbot
 
 ## What's New
 
+### v3.37 — Dream Mode, Meta-Agent, Claude Code Plugin, Voice Mode
+
+| Feature | What it means |
+|---------|---------------|
+| **Dream Mode** | `kbot dream` — offline consolidation. kbot reviews recent sessions, extracts patterns, strengthens memory connections, and prunes stale knowledge. Like sleep for an AI agent. |
+| **Meta-Agent** | Self-referential self-improvement inspired by HyperAgents ([arXiv 2603.19461](https://arxiv.org/abs/2603.19461)). A two-agent loop: task agents solve problems, the Meta-Agent watches performance and rewrites task agents to be better. Unlike HyperAgents (CC BY-NC-SA), kbot is MIT — the only self-improving agent framework companies can actually use. Run `kbot meta` to trigger a cycle. |
+| **Claude Code Plugin** | kbot registers its 9 core specialists as Claude Code teammates via the Agent Teams integration. Delegate tasks to `coder`, `researcher`, `guardian`, etc. directly from Claude Code sessions. |
+| **Voice Mode** | `kbot voice` — full voice loop with speech-to-text input and text-to-speech output. Hands-free agentic coding. Works with system TTS and Whisper STT. |
+| **OpenClaw Integration** | [`@kernel.chat/kbot-openclaw`](https://www.npmjs.com/package/@kernel.chat/kbot-openclaw) — kbot as the brain for 50+ messaging channels. Discord, Slack, Telegram, WhatsApp, iMessage, email, and more. One agent, every platform. |
+| **41 agents** | 15 new specialist and domain agents since v3.28, including meta-agent, dream agent, and expanded presets. |
+| **384+ tools** | 34 new tools across finance, creative, build matrix, and meta-cognition categories. |
+
 ### v3.28 — Self-Defense System
 
 kbot now protects its own integrity — and yours.
@@ -76,7 +88,7 @@ Other AI agents are static — fixed tools, single providers, no memory, no lear
 - **20 providers, zero lock-in** — Claude, GPT, Gemini, Grok, DeepSeek, Groq, Mistral, and 13 more. Switch anytime.
 - **Runs fully offline** — Embedded llama.cpp runs GGUF models directly. No Ollama needed. $0, fully private.
 - **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster and smarter over time.
-- **26 specialist agents** — Say "fix the auth bug" and it routes to `coder`. Say "research JWT tokens" and it routes to `researcher`. Say "analyze BTC" and it routes to `trader`. Auto-routed with probabilistic confidence.
+- **41 specialist agents** — Say "fix the auth bug" and it routes to `coder`. Say "research JWT tokens" and it routes to `researcher`. Say "analyze BTC" and it routes to `trader`. Auto-routed with probabilistic confidence.
 - **Crash-proof** — Checkpoints after every tool call. Resume interrupted sessions automatically.
 - **Use as a library** — Clean SDK with typed exports. Build your own tools on top of kbot.
 - **Works in your IDE** — Built-in MCP server for VS Code, Cursor, Zed, Neovim. ACP for JetBrains.
@@ -165,7 +177,7 @@ for await (const event of agent.stream("explain this code")) {
 const files = await tools.execute('glob', { pattern: 'src/**/*.ts' })
 console.log(files.result)
 
-// List all 350+ tools
+// List all 384+ tools
 console.log(tools.list().map(t => t.name))
 ```
 
@@ -179,15 +191,16 @@ import { ResponseStream } from '@kernel.chat/kbot'                     // Stream
 
 ## Specialists
 
-26 agents, auto-routed by Bayesian skill ratings, or pick one with `kbot --agent <name>`:
+41 agents, auto-routed by Bayesian skill ratings, or pick one with `kbot --agent <name>`:
 
 | | Agents |
 |---|---|
 | **Core** | kernel, researcher, coder, writer, analyst |
 | **Extended** | aesthete, guardian, curator, strategist |
 | **Domain** | infrastructure, quant, investigator, oracle, chronist, sage, communicator, adapter, trader |
-| **System** | immune, forge |
+| **System** | immune, forge, meta-agent, dream, codebase-guardian |
 | **Presets** | hacker, operator, dreamer, creative, developer, gamedev, playtester |
+| **Claude Code** | kernel, coder, researcher, writer, analyst, guardian, aesthete, curator, strategist (teammate integration) |
 
 ```bash
 kbot --agent researcher "what papers cite Friston's Free Energy Principle?"
@@ -196,7 +209,7 @@ kbot --agent coder "refactor this into smaller functions"
 kbot --agent trader "analyze BTC momentum and run a paper trade"
 ```
 
-## 345+ Tools
+## 384+ Tools
 
 | Category | Examples |
 |----------|---------|
@@ -436,6 +449,97 @@ kbot's agent loop runs 11 always-on cognition modules based on peer-reviewed res
 
 These aren't metaphors. They're TypeScript modules with paper citations in the headers. The interference between modules — not the modules themselves — is where intelligent behavior emerges. See the [research paper](../../docs/cognitive-module-interference.md).
 
+## Dream Mode
+
+```bash
+kbot dream
+```
+
+Offline memory consolidation. When you run `kbot dream`, kbot reviews recent sessions, extracts recurring patterns, strengthens high-value memory connections, and prunes stale or contradictory knowledge. Think of it as sleep for an AI agent — the work that makes tomorrow's sessions faster and more accurate.
+
+- **Pattern extraction** — identifies recurring tool sequences, user preferences, and project conventions
+- **Memory pruning** — removes outdated facts and conflicting entries
+- **Skill strengthening** — reinforces Bayesian skill ratings based on real outcomes
+- **Knowledge synthesis** — connects isolated learnings into higher-level insights
+- **Runs fully local** — no API calls, no data leaves your machine
+
+## Meta-Agent
+
+```bash
+kbot meta
+```
+
+Self-referential self-improvement. Inspired by Meta's HyperAgents paper ([arXiv 2603.19461](https://arxiv.org/abs/2603.19461)), the Meta-Agent implements a two-agent architecture:
+
+1. **Task agents** solve problems (the 41 specialists you already use)
+2. **The Meta-Agent** observes their performance, identifies weaknesses, and improves them
+
+The improvement loop runs automatically:
+- **Observe** — records success/failure, duration, cost, and tool usage for every task
+- **Analyze** — builds performance profiles per agent, identifies failure patterns
+- **Propose** — generates targeted improvements (prompt rewrites, tool pre-selection, routing changes)
+- **Apply** — auto-applies low-risk improvements (routing, tool selection); flags high-risk ones for review
+- **Measure** — compares before/after performance and reverts regressions
+
+Unlike HyperAgents (CC BY-NC-SA, non-commercial license), kbot is MIT — the only self-improving agent framework that companies can actually deploy in production.
+
+```bash
+kbot meta              # Run one improvement cycle
+kbot meta stats        # View cycle count, observations, active improvements
+kbot meta history      # Review all past improvements
+```
+
+## Claude Code Plugin
+
+kbot integrates directly with Claude Code as a teammate provider. Register kbot's specialists so Claude Code can delegate tasks to the right expert:
+
+```typescript
+import { registerTeammates, delegateToTeammate } from '@kernel.chat/kbot'
+
+// Get teammate definitions for all 9 core specialists
+const teammates = registerTeammates()
+// → [{ name: 'kernel', model: 'sonnet', ... }, { name: 'coder', ... }, ...]
+
+// Delegate a task to a specific specialist
+const result = await delegateToTeammate('guardian', 'audit src/auth.ts for security issues')
+console.log(result.content)   // security analysis
+console.log(result.toolCalls) // tools used (dep_audit, secret_scan, etc.)
+```
+
+Each teammate definition includes:
+- **name** — agent identifier (`kernel`, `coder`, `researcher`, `writer`, `analyst`, `guardian`, `aesthete`, `curator`, `strategist`)
+- **model** — `opus` for complex reasoning agents (analyst, strategist, guardian, researcher), `sonnet` for fast agents
+- **initialPrompt** — the specialist's full system prompt
+- **tools** — preferred tool list for the specialist's domain
+
+## Voice Mode
+
+```bash
+kbot voice
+```
+
+Full voice loop — speak your tasks, hear the results. Voice mode chains speech-to-text input with text-to-speech output for hands-free agentic coding:
+
+- **STT** — Whisper-based transcription (local or API)
+- **TTS** — System speech synthesis (macOS `say`, Linux `espeak`, or cloud TTS)
+- **Continuous** — voice loop stays open between turns, no re-activation needed
+- **Tool narration** — kbot announces tool calls and results as it works
+
+## OpenClaw Integration
+
+```bash
+npm install @kernel.chat/kbot-openclaw
+```
+
+kbot as the brain for 50+ messaging channels. OpenClaw bridges kbot's agent loop to Discord, Slack, Telegram, WhatsApp, iMessage, email, Matrix, and more — one agent, every platform.
+
+- **Channel-agnostic** — same agent logic regardless of input source
+- **Per-channel memory** — separate conversation contexts per channel/user
+- **Rate limiting** — configurable per-platform rate limits
+- **Media handling** — images, files, and voice messages routed through kbot's multimodal pipeline
+
+See [`@kernel.chat/kbot-openclaw`](https://www.npmjs.com/package/@kernel.chat/kbot-openclaw) on npm.
+
 ## Security
 
 kbot has two layers of security: protecting **your projects** and protecting **itself**.
@@ -514,7 +618,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, adding tools, and
 </details>
 
 <details>
-<summary><strong>Agent Routing</strong> — 26 specialists, auto-routed by intent</summary>
+<summary><strong>Agent Routing</strong> — 41 specialists, auto-routed by intent</summary>
 <img src="../../tools/video-assets/demo-agents.gif" alt="kbot agent routing" width="700">
 </details>
 

package/dist/agent-teams.d.ts

@@ -0,0 +1,55 @@
+export interface TeammateDefinition {
+    /** Agent identifier */
+    name: string;
+    /** What this specialist focuses on */
+    description: string;
+    /** Model tier: 'sonnet' for fast agents, 'opus' for complex reasoning */
+    model: 'sonnet' | 'opus';
+    /** System prompt that defines the specialist's behavior */
+    initialPrompt: string;
+    /** Preferred tools for this specialist */
+    tools: string[];
+}
+export interface DelegationResult {
+    /** The response content from the teammate */
+    content: string;
+    /** Which agent handled the task */
+    agent: string;
+    /** Model used */
+    model: string;
+    /** Number of tool calls made */
+    toolCalls: number;
+    /** Token usage, if available */
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+    };
+}
+/**
+ * Register kbot specialists as Claude Code teammates.
+ *
+ * Returns an array of teammate definitions — one for each of kbot's
+ * core and extended specialist agents (9 total).
+ *
+ * @example
+ * const teammates = registerTeammates()
+ * // teammates[0] = { name: 'kernel', model: 'sonnet', ... }
+ */
+export declare function registerTeammates(): TeammateDefinition[];
+/**
+ * Delegate a task to a specific kbot teammate by name.
+ *
+ * Routes the task through kbot's full agent loop (think -> plan -> execute -> learn)
+ * using a silent UI adapter so output is captured, not printed.
+ *
+ * @param name - The teammate/specialist ID (e.g. 'coder', 'researcher')
+ * @param task - The task description or prompt to execute
+ * @returns The delegation result with content, agent info, and usage stats
+ *
+ * @example
+ * const result = await delegateToTeammate('coder', 'add input validation to auth.ts')
+ * console.log(result.content)
+ */
+export declare function delegateToTeammate(name: string, task: string): Promise<DelegationResult>;
+//# sourceMappingURL=agent-teams.d.ts.map

package/dist/agent-teams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-teams.d.ts","sourceRoot":"","sources":["../src/agent-teams.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,kBAAkB;IACjC,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAA;IACxB,2DAA2D;IAC3D,aAAa,EAAE,MAAM,CAAA;IACrB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,gCAAgC;IAChC,KAAK,CAAC,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAC1E;AAgED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,kBAAkB,EAAE,CAoBxD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CA2B3B"}

package/dist/agent-teams.js

@@ -0,0 +1,135 @@
+// kbot Agent Teams — Claude Code Teammate Integration
+//
+// Registers kbot's specialist agents as Claude Code teammates so they
+// can be invoked collaboratively within a Claude Code session.
+//
+// Usage:
+//   import { registerTeammates, delegateToTeammate } from './agent-teams.js'
+//
+//   const teammates = registerTeammates()
+//   const result = await delegateToTeammate('coder', 'refactor auth.ts into smaller functions')
+import { SPECIALISTS } from './agents/specialists.js';
+import { runAgent } from './agent.js';
+import { SilentUIAdapter } from './ui-adapter.js';
+// ── Teammate tool mappings ──────────────────────────────────────────────────
+const TOOL_PREFERENCES = {
+    kernel: [
+        'read_file', 'write_file', 'glob', 'grep', 'bash',
+        'web_search', 'memory_save', 'memory_search',
+    ],
+    coder: [
+        'read_file', 'write_file', 'edit_file', 'glob', 'grep', 'bash',
+        'git_status', 'git_diff', 'git_commit', 'lint', 'test_runner',
+        'type_check', 'format_code',
+    ],
+    researcher: [
+        'web_search', 'url_fetch', 'read_file', 'grep', 'glob',
+        'arxiv_search', 'semantic_scholar', 'memory_save',
+    ],
+    writer: [
+        'read_file', 'write_file', 'edit_file', 'glob', 'grep',
+        'web_search', 'url_fetch',
+    ],
+    analyst: [
+        'read_file', 'glob', 'grep', 'bash', 'web_search',
+        'url_fetch', 'csv_read', 'csv_query',
+    ],
+    guardian: [
+        'read_file', 'glob', 'grep', 'bash', 'dep_audit',
+        'secret_scan', 'ssl_check', 'headers_check', 'cve_lookup',
+        'port_scan', 'owasp_check',
+    ],
+    aesthete: [
+        'read_file', 'write_file', 'edit_file', 'glob', 'grep',
+        'bash', 'design_variants',
+    ],
+    curator: [
+        'read_file', 'write_file', 'edit_file', 'glob', 'grep',
+        'memory_save', 'memory_search', 'web_search',
+    ],
+    strategist: [
+        'read_file', 'glob', 'grep', 'web_search', 'url_fetch',
+        'bash', 'csv_read', 'csv_query',
+    ],
+};
+// Agents that benefit from complex reasoning get opus; others use sonnet for speed
+const OPUS_AGENTS = new Set(['analyst', 'strategist', 'guardian', 'researcher']);
+// ── Teammate descriptions ───────────────────────────────────────────────────
+const DESCRIPTIONS = {
+    kernel: 'General-purpose assistant — handles conversation, coordination, and tasks that span multiple domains.',
+    coder: 'Programming specialist — writes, reviews, refactors, and debugs production-quality code across all major languages.',
+    researcher: 'Research specialist — finds, verifies, and synthesizes information from web, papers, and codebases.',
+    writer: 'Content specialist — writes docs, blog posts, changelogs, emails, and social media with appropriate tone and structure.',
+    analyst: 'Strategy & evaluation specialist — breaks down complex decisions with data-driven analysis and frameworks.',
+    guardian: 'Security specialist — audits code, scans dependencies, checks for vulnerabilities, and hardens systems.',
+    aesthete: 'Design specialist — evaluates and creates UI/UX, enforces design systems, and ensures accessibility.',
+    curator: 'Knowledge management specialist — organizes documentation, maintains knowledge bases, and fills information gaps.',
+    strategist: 'Business strategy specialist — connects technical decisions to business outcomes, builds roadmaps, and analyzes competitors.',
+};
+// ── Core API ────────────────────────────────────────────────────────────────
+/**
+ * Register kbot specialists as Claude Code teammates.
+ *
+ * Returns an array of teammate definitions — one for each of kbot's
+ * core and extended specialist agents (9 total).
+ *
+ * @example
+ * const teammates = registerTeammates()
+ * // teammates[0] = { name: 'kernel', model: 'sonnet', ... }
+ */
+export function registerTeammates() {
+    const teammateIds = [
+        'kernel', 'coder', 'researcher', 'writer', 'analyst',
+        'guardian', 'aesthete', 'curator', 'strategist',
+    ];
+    return teammateIds.map((id) => {
+        const specialist = SPECIALISTS[id];
+        if (!specialist) {
+            throw new Error(`Specialist "${id}" not found in SPECIALISTS registry.`);
+        }
+        return {
+            name: id,
+            description: DESCRIPTIONS[id] ?? specialist.name,
+            model: OPUS_AGENTS.has(id) ? 'opus' : 'sonnet',
+            initialPrompt: specialist.prompt,
+            tools: TOOL_PREFERENCES[id] ?? TOOL_PREFERENCES.kernel,
+        };
+    });
+}
+/**
+ * Delegate a task to a specific kbot teammate by name.
+ *
+ * Routes the task through kbot's full agent loop (think -> plan -> execute -> learn)
+ * using a silent UI adapter so output is captured, not printed.
+ *
+ * @param name - The teammate/specialist ID (e.g. 'coder', 'researcher')
+ * @param task - The task description or prompt to execute
+ * @returns The delegation result with content, agent info, and usage stats
+ *
+ * @example
+ * const result = await delegateToTeammate('coder', 'add input validation to auth.ts')
+ * console.log(result.content)
+ */
+export async function delegateToTeammate(name, task) {
+    // Validate the teammate exists
+    const specialist = SPECIALISTS[name];
+    if (!specialist) {
+        const available = Object.keys(SPECIALISTS).join(', ');
+        throw new Error(`Unknown teammate "${name}". Available: ${available}`);
+    }
+    const ui = new SilentUIAdapter();
+    const options = {
+        agent: name,
+        stream: false,
+        ui,
+    };
+    const response = await runAgent(task, options);
+    return {
+        content: response.content ?? ui.content ?? '',
+        agent: response.agent ?? name,
+        model: response.model ?? '',
+        toolCalls: response.toolCalls ?? 0,
+        usage: response.usage,
+    };
+}
+//# sourceMappingURL=agent-teams.js.map

package/dist/agent-teams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-teams.js","sourceRoot":"","sources":["../src/agent-teams.ts"],"names":[],"mappings":"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"}

package/dist/codebase-guardian.d.ts

@@ -0,0 +1,64 @@
+export type FindingType = 'duplicate-pattern' | 'co-change' | 'complexity';
+export interface GuardianFinding {
+    type: FindingType;
+    severity: 'info' | 'warn' | 'critical';
+    title: string;
+    description: string;
+    files: string[];
+    /** The repeated code snippet (for duplicate-pattern findings) */
+    pattern?: string;
+    /** Occurrence count (for duplicate-pattern findings) */
+    occurrences?: number;
+    /** Metric value (for complexity findings — e.g., function length) */
+    metric?: number;
+    /** Suggested action */
+    suggestion: string;
+    foundAt: string;
+}
+export interface GuardianReport {
+    analyzedAt: string;
+    rootDir: string;
+    filesScanned: number;
+    findings: GuardianFinding[];
+    summary: {
+        duplicates: number;
+        coChanges: number;
+        complexityWarnings: number;
+        totalFindings: number;
+    };
+}
+export interface ForgedGuardianTool {
+    name: string;
+    description: string;
+    finding: GuardianFinding;
+    detectPattern: string;
+    createdAt: string;
+}
+interface HistoryEntry {
+    report: GuardianReport;
+    forgedTools: string[];
+}
+/**
+ * Run the Codebase Guardian on a directory.
+ *
+ * Scans for:
+ * - Duplicate code patterns (3+ occurrences across files)
+ * - Files that always change together (from git history)
+ * - Growing complexity (function length, nesting depth)
+ *
+ * Returns a structured report with all findings.
+ */
+export declare function runGuardian(path: string): Promise<GuardianReport>;
+/**
+ * When the guardian finds a recurring pattern, forge a tool to detect (and
+ * optionally fix) that specific pattern in the future.
+ *
+ * The forged tool is saved to ~/.kbot/forge/guardian-{name}.json.
+ */
+export declare function forgeGuardianTool(finding: GuardianFinding): ForgedGuardianTool;
+/**
+ * Get history of guardian reports and forged tools.
+ */
+export declare function getGuardianHistory(): HistoryEntry[];
+export {};
+//# sourceMappingURL=codebase-guardian.d.ts.map

package/dist/codebase-guardian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-guardian.d.ts","sourceRoot":"","sources":["../src/codebase-guardian.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG,WAAW,GAAG,YAAY,CAAA;AAE1E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAA;IACtC,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,iEAAiE;IACjE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAA;QAClB,SAAS,EAAE,MAAM,CAAA;QACjB,kBAAkB,EAAE,MAAM,CAAA;QAC1B,aAAa,EAAE,MAAM,CAAA;KACtB,CAAA;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,eAAe,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,cAAc,CAAA;IACtB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB;AA2ZD;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CA8CvE;AAID;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,kBAAkB,CA8D9E;AAID;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,EAAE,CAEnD"}