@easynet/agent-runtime 1.0.2 → 1.0.4

package/apps/itermbot/src/startup/colors.ts

@@ -0,0 +1,317 @@
+/**
+ * Startup panel coloring for iTermBot.
+ *
+ * Sets distinct background + foreground colors on the chat panel and
+ * target panels within the **current tab**, using a professional
+ * light-on-dark scheme for both.
+ *
+ * Identifies the chat panel by matching process TTY against session TTY.
+ *
+ * Called from the onReady hook — failures are non-fatal.
+ */
+import { execFileSync } from "node:child_process";
+import {
+  itermListCurrentWindowSessions,
+  itermSplitPane,
+  itermSetSessionColors,
+} from "@easynet/agent-tool-buildin/iterm";
+
+/* ------------------------------------------------------------------ */
+/*  Color scheme                                                       */
+/* ------------------------------------------------------------------ */
+
+// Chat panel: soft slate-blue background, light silver text
+export const CHAT_BG = "#1E2D3D";
+export const CHAT_FG = "#D4D7DC";
+
+// Target panel: dark warm charcoal background, soft warm white text
+export const TARGET_BG = "#2A2A2A";
+export const TARGET_FG = "#E8E0D4";
+
+/* ------------------------------------------------------------------ */
+
+interface SessionInfo {
+  windowId?: number;
+  tabIndex?: number;
+  sessionId?: string;
+  tty?: string;
+  isCurrentSession?: boolean;
+  isCurrentTab?: boolean;
+}
+
+export interface SessionColorSnapshot {
+  windowId: number;
+  tabIndex: number;
+  sessionId: string;
+  background: [number, number, number];
+  foreground: [number, number, number];
+}
+
+function quoteAppleScriptString(input: string): string {
+  return `"${input.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function runOsaScriptSync(lines: string[]): string {
+  const args: string[] = [];
+  for (const line of lines) {
+    args.push("-e", line);
+  }
+  return execFileSync("osascript", args, {
+    encoding: "utf-8",
+    timeout: 3000,
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function parseColorTuple(raw: string): [number, number, number] | null {
+  const values = raw
+    .split(",")
+    .map((v) => Number(v.trim()))
+    .filter((v) => Number.isFinite(v));
+  if (values.length < 3) return null;
+  return [values[0]!, values[1]!, values[2]!];
+}
+
+function captureSessionColorsSync(args: {
+  windowId: number;
+  tabIndex: number;
+  sessionId: string;
+}): SessionColorSnapshot | null {
+  try {
+    const sid = quoteAppleScriptString(args.sessionId);
+    const script = [
+      'tell application "iTerm"',
+      `set targetWindow to first window whose id is ${Math.trunc(args.windowId)}`,
+      `set targetTab to tab ${Math.max(1, Math.trunc(args.tabIndex))} of targetWindow`,
+      "set targetSession to missing value",
+      "try",
+      `set targetSession to first session of targetTab whose unique id is ${sid}`,
+      "on error",
+      `set targetSession to first session of targetTab whose id is ${sid}`,
+      "end try",
+      "set bg to background color of targetSession",
+      "set fg to foreground color of targetSession",
+      "return (item 1 of bg as text) & \",\" & (item 2 of bg as text) & \",\" & (item 3 of bg as text) & \"|\" & (item 1 of fg as text) & \",\" & (item 2 of fg as text) & \",\" & (item 3 of fg as text)",
+      "end tell",
+    ];
+    const out = runOsaScriptSync(script);
+    const [bgRaw, fgRaw] = out.split("|");
+    const bg = parseColorTuple(bgRaw ?? "");
+    const fg = parseColorTuple(fgRaw ?? "");
+    if (!bg || !fg) return null;
+    return {
+      windowId: args.windowId,
+      tabIndex: args.tabIndex,
+      sessionId: args.sessionId,
+      background: bg,
+      foreground: fg,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function captureSessionColorsByIdSync(args: {
+  windowId: number;
+  tabIndex: number;
+  sessionId: string;
+}): SessionColorSnapshot | null {
+  return captureSessionColorsSync(args);
+}
+
+export function restoreSessionColorsSync(snapshots: SessionColorSnapshot[]): void {
+  for (const s of snapshots) {
+    try {
+      const sid = quoteAppleScriptString(s.sessionId);
+      const [br, bg, bb] = s.background;
+      const [fr, fg, fb] = s.foreground;
+      const script = [
+        'tell application "iTerm"',
+        `set targetWindow to first window whose id is ${Math.trunc(s.windowId)}`,
+        `set targetTab to tab ${Math.max(1, Math.trunc(s.tabIndex))} of targetWindow`,
+        "set targetSession to missing value",
+        "try",
+        `set targetSession to first session of targetTab whose unique id is ${sid}`,
+        "on error",
+        `set targetSession to first session of targetTab whose id is ${sid}`,
+        "end try",
+        `set background color of targetSession to {${br}, ${bg}, ${bb}}`,
+        `set foreground color of targetSession to {${fr}, ${fg}, ${fb}}`,
+        "end tell",
+      ];
+      runOsaScriptSync(script);
+    } catch {
+      // ignore restore failures during process shutdown
+    }
+  }
+}
+
+/**
+ * Walk up the process tree to find the controlling TTY.
+ */
+function findProcessTty(): string | null {
+  try {
+    let pid = process.pid;
+    for (let i = 0; i < 10; i++) {
+      const line = execFileSync("ps", ["-o", "ppid=,tty=", "-p", String(pid)], {
+        encoding: "utf-8",
+        timeout: 3000,
+      }).trim();
+      const parts = line.split(/\s+/);
+      const ppid = Number(parts[0]);
+      const tty = parts[1];
+      if (tty && tty !== "??" && tty !== "?") {
+        return `/dev/${tty}`;
+      }
+      if (!ppid || ppid <= 1) break;
+      pid = ppid;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+export interface StartupResult {
+  chatSessionId: string | null;
+  targetSessionId: string | null;
+  windowId: number | null;
+  tabIndex: number | null;
+  colorSnapshots: SessionColorSnapshot[];
+}
+
+export async function applyStartupPanelColors(): Promise<StartupResult> {
+  const empty: StartupResult = {
+    chatSessionId: null,
+    targetSessionId: null,
+    windowId: null,
+    tabIndex: null,
+    colorSnapshots: [],
+  };
+
+  const myTty = findProcessTty();
+  const { result } = await itermListCurrentWindowSessions();
+
+  if (result.count === 0) return empty;
+
+  let sessions = result.sessions as SessionInfo[];
+
+  let chatSession = myTty
+    ? sessions.find((s) => s.tty === myTty)
+    : sessions.find((s) => s.isCurrentSession);
+
+  if (!chatSession) {
+    console.error(
+      `startup-colors: could not identify chat session (tty=${myTty}), skipping`,
+    );
+    return empty;
+  }
+
+  let currentTabIndex = chatSession.tabIndex!;
+  let windowId = (result.windowId ?? chatSession.windowId)!;
+  const chatSessionId = chatSession.sessionId;
+
+  let sameTabSessions = sessions.filter(
+    (s) => s.tabIndex === currentTabIndex,
+  );
+  let targetSessions = sameTabSessions.filter(
+    (s) => s.sessionId !== chatSessionId,
+  );
+
+  // If only chat panel exists, split once to create target panel on startup.
+  if (sameTabSessions.length === 1 && chatSessionId) {
+    try {
+      await itermSplitPane({
+        windowId,
+        tabIndex: currentTabIndex,
+        sessionId: chatSessionId,
+        direction: "vertical",
+        activate: false,
+      });
+
+      const refreshed = await itermListCurrentWindowSessions();
+      sessions = refreshed.result.sessions as SessionInfo[];
+      const preservedChat = sessions.find((s) => s.sessionId === chatSessionId);
+      if (preservedChat) {
+        chatSession = preservedChat;
+      }
+      currentTabIndex = chatSession.tabIndex ?? currentTabIndex;
+      windowId = (refreshed.result.windowId ?? chatSession.windowId ?? windowId)!;
+      sameTabSessions = sessions.filter((s) => s.tabIndex === currentTabIndex);
+      targetSessions = sameTabSessions.filter((s) => s.sessionId !== chatSessionId);
+    } catch (err) {
+      console.error(
+        "startup-colors: failed to auto-split single panel:",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  }
+
+  const selectedTarget = targetSessions[0] ?? null;
+
+  const startupResult: StartupResult = {
+    chatSessionId: chatSession.sessionId ?? null,
+    targetSessionId: selectedTarget?.sessionId ?? null,
+    windowId,
+    tabIndex: currentTabIndex,
+    colorSnapshots: [],
+  };
+
+  const sessionsToSnapshot = [
+    chatSession,
+    ...(selectedTarget ? [selectedTarget] : []),
+  ].filter((s): s is Required<Pick<SessionInfo, "sessionId">> & SessionInfo => Boolean(s.sessionId));
+
+  const seen = new Set<string>();
+  for (const s of sessionsToSnapshot) {
+    if (!s.sessionId || seen.has(s.sessionId)) continue;
+    seen.add(s.sessionId);
+    const snapshot = captureSessionColorsSync({
+      windowId,
+      tabIndex: currentTabIndex,
+      sessionId: s.sessionId,
+    });
+    if (snapshot) {
+      startupResult.colorSnapshots.push(snapshot);
+    }
+  }
+
+  const tasks: Promise<unknown>[] = [];
+
+  if (chatSession.sessionId) {
+    tasks.push(
+      itermSetSessionColors({
+        windowId,
+        tabIndex: currentTabIndex,
+        sessionId: chatSession.sessionId,
+        backgroundHex: CHAT_BG,
+        foregroundHex: CHAT_FG,
+      }),
+    );
+  }
+
+  if (selectedTarget?.sessionId) {
+    tasks.push(
+      itermSetSessionColors({
+        windowId,
+        tabIndex: currentTabIndex,
+        sessionId: selectedTarget.sessionId,
+        backgroundHex: TARGET_BG,
+        foregroundHex: TARGET_FG,
+      }),
+    );
+  }
+
+  const results = await Promise.allSettled(tasks);
+
+  for (const r of results) {
+    if (r.status === "rejected") {
+      console.error(
+        "startup-colors: failed to set color on a session:",
+        r.reason?.message ?? r.reason,
+      );
+    }
+  }
+
+  return startupResult;
+}

package/apps/itermbot/src/startup/diagnostics.ts

@@ -0,0 +1,97 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { loadYamlFile } from "@easynet/agent-common";
+import { formatLogPath, resolveConfigPath } from "./ui.js";
+
+export async function getLlmSelectionLabel(modelsPath: string): Promise<string> {
+  try {
+    const raw = await loadYamlFile<Record<string, unknown>>(modelsPath);
+    const spec = raw?.spec && typeof raw.spec === "object" && !Array.isArray(raw.spec)
+      ? (raw.spec as Record<string, unknown>)
+      : undefined;
+    const llm = ((spec?.llm ?? raw?.llm) ?? null) as Record<string, unknown> | null;
+    if (!llm) return "name=unknown, model=unknown";
+    const selectedName =
+      typeof llm.default === "string" && llm.default.trim().length > 0
+        ? llm.default.trim()
+        : "unknown";
+    const selected = llm[selectedName];
+    const selectedRec =
+      typeof selected === "object" && selected !== null
+        ? (selected as Record<string, unknown>)
+        : null;
+    const model =
+      selectedRec && typeof selectedRec.model === "string" && selectedRec.model.trim().length > 0
+        ? selectedRec.model.trim()
+        : "unknown";
+    return `name=${selectedName}, model=${model}`;
+  } catch {
+    return "name=unknown, model=unknown";
+  }
+}
+
+export async function getSkillsPathLabel(config: unknown, agentName: string): Promise<string> {
+  const app = (config as { app?: unknown } | null)?.app as
+    | { agent?: Record<string, { skills?: { ref?: string } }> }
+    | undefined;
+  const firstAgent = app?.agent ? Object.values(app.agent)[0] : undefined;
+  const agent = app?.agent?.[agentName] ?? firstAgent;
+  const skillsConfigPathRaw = agent?.skills?.ref;
+  if (!skillsConfigPathRaw || typeof skillsConfigPathRaw !== "string") {
+    const localSkillsDir = resolve(process.cwd(), "skills");
+    if (existsSync(localSkillsDir)) {
+      return `skills=auto(${formatLogPath(localSkillsDir)})`;
+    }
+    return "skills=auto(module-default)";
+  }
+  const skillsConfigPath = resolveConfigPath(skillsConfigPathRaw);
+  try {
+    const raw = await loadYamlFile<Record<string, unknown>>(skillsConfigPath);
+    const spec = (raw?.spec && typeof raw.spec === "object" && !Array.isArray(raw.spec))
+      ? (raw.spec as Record<string, unknown>)
+      : undefined;
+    const skillsDirRaw = typeof spec?.path === "string"
+      ? spec.path
+      : (typeof raw?.path === "string" ? raw.path : "");
+    if (!skillsDirRaw) return `${formatLogPath(skillsConfigPath)} -> (unknown)`;
+    const skillsDir = resolve(dirname(skillsConfigPath), skillsDirRaw);
+    return `${formatLogPath(skillsConfigPath)} -> ${formatLogPath(skillsDir)}`;
+  } catch {
+    return `${formatLogPath(skillsConfigPath)} -> (unreadable)`;
+  }
+}
+
+function extractLlmText(output: unknown): string {
+  const content = (output as { content?: unknown } | null)?.content;
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (typeof part === "object" && part && "text" in part) {
+          const text = (part as { text?: unknown }).text;
+          return typeof text === "string" ? text : "";
+        }
+        return "";
+      })
+      .join(" ")
+      .trim();
+  }
+  return "";
+}
+
+export async function runLlmHealthCheck(llm: { invoke: (input: string) => Promise<unknown> }): Promise<string> {
+  const timeoutMs = Number(process.env.ITERMBOT_LLM_HEALTHCHECK_TIMEOUT_MS ?? "12000");
+  const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 12000;
+
+  const invokePromise = llm.invoke("Health check: reply with OK only.");
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => reject(new Error(`LLM health check timeout (${timeout}ms)`)), timeout);
+  });
+  const output = await Promise.race([invokePromise, timeoutPromise]);
+  const text = extractLlmText(output);
+  if (!text) {
+    throw new Error("LLM health check returned empty response");
+  }
+  return text.length > 32 ? `${text.slice(0, 32)}...` : text;
+}

package/apps/itermbot/src/startup/ui.ts

@@ -0,0 +1,141 @@
+import { readFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function toErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function formatLogPath(pathValue: string): string {
+  const trimmed = pathValue.trim();
+  if (!trimmed) return "(unknown)";
+  const rel = relative(process.cwd(), trimmed);
+  if (!rel || rel.startsWith("..")) return trimmed;
+  return rel;
+}
+
+export function resolveConfigPath(pathValue: string): string {
+  return pathValue.startsWith("/") ? pathValue : resolve(process.cwd(), pathValue);
+}
+
+function formatDurationMs(durationMs: number | null): string {
+  return durationMs === null ? "" : ` (${durationMs}ms)`;
+}
+
+export function clearStartupNoise(): void {
+  if (!process.stdout.isTTY) return;
+  process.stdout.write("\x1b[2J\x1b[H");
+}
+
+export function printStartupBanner(): void {
+  const lines = [
+    "  _ _____                   ____        _   ",
+    " (_)_   _|__ _ __ _ __ ___ | __ )  ___ | |_ ",
+    " | | | |/ _ \\ '__| '_ ` _ \\|  _ \\ / _ \\| __|",
+    " | | | |  __/ |  | | | | | | |_) | (_) | |_ ",
+    " |_| |_|\\___|_|  |_| |_| |_|____/ \\___/ \\__|",
+    "                   iTermBot                 ",
+  ];
+  console.log("--------------------------------------------------------------------------------------------------");
+  console.log(`\n${lines.join("\n")}`);
+  console.log("      Observe the terminal. Act with precision.\n");
+}
+
+export function getAppVersion(): string {
+  try {
+    const currentFile = fileURLToPath(import.meta.url);
+    const packageJsonPath = resolve(dirname(currentFile), "../package.json");
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { version?: unknown };
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+export function printStartupSummary(args: { version: string }): void {
+  console.log("\n--------------------------------------------------------------------------------------------------");
+  console.log(`Version   : v${args.version}`);
+  console.log(`Workspace : ${process.cwd()}`);
+  console.log("");
+  console.log("Commands  : list tools, list skills, exit");
+  console.log("--------------------------------------------------------------------------------------------------\n");
+}
+
+export class StartupProgressRenderer {
+  private readonly isDynamic = Boolean(process.stdout.isTTY);
+  private readonly frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private readonly lineByStep = new Map<string, number>();
+  private readonly timerByStep = new Map<string, NodeJS.Timeout>();
+  private readonly frameIndexByStep = new Map<string, number>();
+  private lineCount = 0;
+
+  start(stepId: string, title: string): void {
+    const baseLabel = `[startup] ${title}`;
+    if (!this.isDynamic) {
+      console.log(`${baseLabel} ...`);
+      return;
+    }
+    const lineIndex = this.lineCount;
+    this.lineByStep.set(stepId, lineIndex);
+    this.frameIndexByStep.set(stepId, 0);
+    this.lineCount += 1;
+    process.stdout.write(`\r${baseLabel} ${this.frames[0]}\n`);
+    const timer = setInterval(() => {
+      const current = this.frameIndexByStep.get(stepId);
+      if (current === undefined) return;
+      const next = (current + 1) % this.frames.length;
+      this.frameIndexByStep.set(stepId, next);
+      this.renderLine(stepId, `${baseLabel} ${this.frames[next]}`);
+    }, 80);
+    this.timerByStep.set(stepId, timer);
+  }
+
+  complete(stepId: string, title: string, ok: boolean, detail: string, elapsedMs: number): void {
+    const baseLabel = `[startup] ${title}`;
+    const mark = ok ? "✅" : "✖";
+    const detailPart = detail.trim().length > 0 ? ` ${detail}` : "";
+    const finalLine = `${mark} ${baseLabel}${detailPart}${formatDurationMs(elapsedMs)}`;
+    const timer = this.timerByStep.get(stepId);
+    if (timer) {
+      clearInterval(timer);
+      this.timerByStep.delete(stepId);
+    }
+    this.frameIndexByStep.delete(stepId);
+    if (!this.isDynamic) {
+      console.log(finalLine);
+      return;
+    }
+    this.renderLine(stepId, finalLine);
+  }
+
+  private renderLine(stepId: string, line: string): void {
+    const lineIndex = this.lineByStep.get(stepId);
+    if (lineIndex === undefined) return;
+    const up = this.lineCount - lineIndex;
+    if (up <= 0) return;
+    process.stdout.write(`\x1b[${up}A\r\x1b[2K${line}\x1b[${up}B\r`);
+  }
+}
+
+export async function runStartupStep<T>(
+  progress: StartupProgressRenderer,
+  title: string,
+  fn: () => Promise<T> | T,
+  formatResult?: (result: T) => string,
+): Promise<T> {
+  const stepId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const startedAt = Date.now();
+  progress.start(stepId, title);
+
+  try {
+    const result = await fn();
+    const detail = formatResult ? formatResult(result) : "";
+    const elapsed = Date.now() - startedAt;
+    progress.complete(stepId, title, true, detail, elapsed);
+    return result;
+  } catch (error) {
+    const elapsed = Date.now() - startedAt;
+    progress.complete(stepId, title, false, toErrorMessage(error), elapsed);
+    throw error;
+  }
+}

package/config/agent.deep.yaml

@@ -0,0 +1,25 @@
+apiVersion: easynet.world/v1
+kind: AgentConfig
+metadata:
+  name: runtime-deep-default
+spec:
+  systemPrompt: |
+    You are an assistant running in Deep Agent mode.
+    Domain rules are provided by app-level prompt templates.
+
+    ## Execution Rules
+    - Solve tasks in clear multi-step order.
+    - Use available tools as the source of truth.
+    - Prefer low-cost actions first; escalate only when needed.
+
+    ## Response Rules
+    - Keep responses concise, structured, and evidence-based.
+    - Do not invent facts not present in observations.
+    - Keep internal reasoning private.
+
+    ## Memory Rules
+    - Use `thread` for session context and transient details.
+    - Use `cross_thread` for durable preferences/facts.
+    - Never store secrets.
+  recursionLimit: 8
+  memoriesPath: /memories/

package/config/agent.react.yaml

@@ -0,0 +1,24 @@
+apiVersion: easynet.world/v1
+kind: AgentConfig
+metadata:
+  name: runtime-react-default
+spec:
+  systemPrompt: |
+    You are an assistant running in ReAct mode.
+    Domain rules are provided by app-level prompt templates.
+
+    ## Tool Calls
+    - When taking an action, output exactly one tool call line: `toolName({ ... })`.
+    - The parentheses must contain exactly one valid JSON object.
+    - No extra wrapper text around tool-call JSON.
+
+    ## Response Rules
+    - Be concise, structured, and evidence-based.
+    - Do not invent facts not present in tool outputs.
+    - Keep internal reasoning private.
+
+    ## Memory Rules
+    - Use `thread` for session context and transient details.
+    - Use `cross_thread` for durable preferences/facts.
+    - Never store secrets.
+  maxSteps: 40

package/dist/agents/deep-agent.d.ts

@@ -0,0 +1,37 @@
+import type { BaseAgentConfig, BotContext } from "../core/context.js";
+export interface DeepAgentRuntime {
+    agent: unknown;
+    run: (userMessage: string) => Promise<{
+        text: string;
+        messages?: unknown;
+    }>;
+}
+export interface DeepAgentOptions {
+    agentName?: string;
+    systemPrompt?: string;
+    recursionLimit?: number;
+    autoWriteMemory?: boolean;
+    printSteps?: boolean;
+    fallbackText?: string;
+    commandWindowLabel?: string;
+}
+export declare function createDeepAgent<TConfig extends BaseAgentConfig>(ctx: BotContext<TConfig>, options?: DeepAgentOptions): Promise<{
+    agent: {
+        invoke: (input: {
+            messages: {
+                role: "user" | "assistant";
+                content: string;
+            }[];
+        }) => Promise<unknown>;
+        withConfig?: ((config: {
+            recursionLimit: number;
+        }) => {
+            invoke: (input: unknown) => Promise<unknown>;
+        }) | undefined;
+    };
+    run(userMessage: string): Promise<{
+        text: string;
+        messages?: unknown;
+    }>;
+}>;
+//# sourceMappingURL=deep-agent.d.ts.map

package/dist/agents/deep-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-agent.d.ts","sourceRoot":"","sources":["../../src/agents/deep-agent.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEtE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAgHD,wBAAsB,eAAe,CAAC,OAAO,SAAS,eAAe,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,GAAE,gBAAqB;;;;sBALjF,MAAM,GAAG,WAAW;yBAAW,MAAM;;cAAU,OAAO,CAAC,OAAO,CAAC;;4BACjE,MAAM;;4BAAyB,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;;;qBAiB5E,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;GAmBhF"}