@xelauvas/xela-cli 0.1.0

package/src/tools/TaskOutputTool/TaskOutputTool.tsx

@@ -0,0 +1,584 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { z } from 'zod/v4';
+import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Box, Text } from '../../ink.js';
+import { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js';
+import type { TaskType } from '../../Task.js';
+import type { Tool } from '../../Tool.js';
+import { buildTool, type ToolDef } from '../../Tool.js';
+import type { LocalAgentTaskState } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
+import type { LocalShellTaskState } from '../../tasks/LocalShellTask/guards.js';
+import type { RemoteAgentTaskState } from '../../tasks/RemoteAgentTask/RemoteAgentTask.js';
+import type { TaskState } from '../../tasks/types.js';
+import { AbortError } from '../../utils/errors.js';
+import { lazySchema } from '../../utils/lazySchema.js';
+import { extractTextContent } from '../../utils/messages.js';
+import { semanticBoolean } from '../../utils/semanticBoolean.js';
+import { sleep } from '../../utils/sleep.js';
+import { jsonParse } from '../../utils/slowOperations.js';
+import { countCharInString } from '../../utils/stringUtils.js';
+import { getTaskOutput } from '../../utils/task/diskOutput.js';
+import { updateTaskState } from '../../utils/task/framework.js';
+import { formatTaskOutput } from '../../utils/task/outputFormatting.js';
+import type { ThemeName } from '../../utils/theme.js';
+import { AgentPromptDisplay, AgentResponseDisplay } from '../AgentTool/UI.js';
+import BashToolResultMessage from '../BashTool/BashToolResultMessage.js';
+import { TASK_OUTPUT_TOOL_NAME } from './constants.js';
+const inputSchema = lazySchema(() => z.strictObject({
+  task_id: z.string().describe('The task ID to get output from'),
+  block: semanticBoolean(z.boolean().default(true)).describe('Whether to wait for completion'),
+  timeout: z.number().min(0).max(600000).default(30000).describe('Max wait time in ms')
+}));
+type InputSchema = ReturnType<typeof inputSchema>;
+type TaskOutputToolInput = z.infer<InputSchema>;
+
+// Unified output type covering all task types
+type TaskOutput = {
+  task_id: string;
+  task_type: TaskType;
+  status: string;
+  description: string;
+  output: string;
+  exitCode?: number | null;
+  error?: string;
+  // For agents
+  prompt?: string;
+  result?: string;
+};
+type TaskOutputToolOutput = {
+  retrieval_status: 'success' | 'timeout' | 'not_ready';
+  task: TaskOutput | null;
+};
+
+// Re-export Progress from centralized types to break import cycles
+export type { TaskOutputProgress as Progress } from '../../types/tools.js';
+
+// Get output for any task type
+async function getTaskOutputData(task: TaskState): Promise<TaskOutput> {
+  let output: string;
+  if (task.type === 'local_bash') {
+    const bashTask = task as LocalShellTaskState;
+    const taskOutputObj = bashTask.shellCommand?.taskOutput;
+    if (taskOutputObj) {
+      const stdout = await taskOutputObj.getStdout();
+      const stderr = taskOutputObj.getStderr();
+      output = [stdout, stderr].filter(Boolean).join('\n');
+    } else {
+      output = await getTaskOutput(task.id);
+    }
+  } else {
+    output = await getTaskOutput(task.id);
+  }
+  const baseOutput: TaskOutput = {
+    task_id: task.id,
+    task_type: task.type,
+    status: task.status,
+    description: task.description,
+    output
+  };
+
+  // Add type-specific fields
+  if (task.type === 'local_bash') {
+    const bashTask = task as LocalShellTaskState;
+    return {
+      ...baseOutput,
+      exitCode: bashTask.result?.code ?? null
+    };
+  }
+  if (task.type === 'local_agent') {
+    const agentTask = task as LocalAgentTaskState;
+    // Prefer the clean final answer from the in-memory result over the raw
+    // JSONL transcript on disk. The disk output is a symlink to the full
+    // session transcript (every message, tool use, etc.), not just the
+    // subagent's answer. The in-memory result contains only the final
+    // assistant text content blocks.
+    const cleanResult = agentTask.result ? extractTextContent(agentTask.result.content, '\n') : undefined;
+    return {
+      ...baseOutput,
+      prompt: agentTask.prompt,
+      result: cleanResult || output,
+      output: cleanResult || output,
+      error: agentTask.error
+    };
+  }
+  if (task.type === 'remote_agent') {
+    const remoteTask = task as RemoteAgentTaskState;
+    return {
+      ...baseOutput,
+      prompt: remoteTask.command
+    };
+  }
+  return baseOutput;
+}
+
+// Wait for task to complete
+async function waitForTaskCompletion(taskId: string, getAppState: () => {
+  tasks?: Record<string, TaskState>;
+}, timeoutMs: number, abortController?: AbortController): Promise<TaskState | null> {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    // Check abort signal
+    if (abortController?.signal.aborted) {
+      throw new AbortError();
+    }
+    const state = getAppState();
+    const task = state.tasks?.[taskId] as TaskState | undefined;
+    if (!task) {
+      return null;
+    }
+    if (task.status !== 'running' && task.status !== 'pending') {
+      return task;
+    }
+
+    // Wait before polling again
+    await sleep(100);
+  }
+
+  // Timeout - return current state
+  const finalState = getAppState();
+  return finalState.tasks?.[taskId] as TaskState ?? null;
+}
+export const TaskOutputTool: Tool<InputSchema, TaskOutputToolOutput> = buildTool({
+  name: TASK_OUTPUT_TOOL_NAME,
+  searchHint: 'read output/logs from a background task',
+  maxResultSizeChars: 100_000,
+  shouldDefer: true,
+  // Backwards-compatible aliases for renamed tools
+  aliases: ['AgentOutputTool', 'BashOutputTool'],
+  userFacingName() {
+    return 'Task Output';
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema();
+  },
+  async description() {
+    return '[Deprecated] — prefer Read on the task output file path';
+  },
+  isConcurrencySafe(_input) {
+    return this.isReadOnly?.(_input) ?? false;
+  },
+  isEnabled() {
+    return "external" !== 'ant';
+  },
+  isReadOnly(_input) {
+    return true;
+  },
+  toAutoClassifierInput(input) {
+    return input.task_id;
+  },
+  async prompt() {
+    return `DEPRECATED: Prefer using the Read tool on the task's output file path instead. Background tasks return their output file path in the tool result, and you receive a <task-notification> with the same path when the task completes — Read that file directly.
+
+- Retrieves output from a running or completed task (background shell, agent, or remote session)
+- Takes a task_id parameter identifying the task
+- Returns the task output along with status information
+- Use block=true (default) to wait for task completion
+- Use block=false for non-blocking check of current status
+- Task IDs can be found using the /tasks command
+- Works with all task types: background shells, async agents, and remote sessions`;
+  },
+  async validateInput({
+    task_id
+  }, {
+    getAppState
+  }) {
+    if (!task_id) {
+      return {
+        result: false,
+        message: 'Task ID is required',
+        errorCode: 1
+      };
+    }
+    const appState = getAppState();
+    const task = appState.tasks?.[task_id] as TaskState | undefined;
+    if (!task) {
+      return {
+        result: false,
+        message: `No task found with ID: ${task_id}`,
+        errorCode: 2
+      };
+    }
+    return {
+      result: true
+    };
+  },
+  async call(input: TaskOutputToolInput, toolUseContext, _canUseTool, _parentMessage, onProgress) {
+    const {
+      task_id,
+      block,
+      timeout
+    } = input;
+    const appState = toolUseContext.getAppState();
+    const task = appState.tasks?.[task_id] as TaskState | undefined;
+    if (!task) {
+      throw new Error(`No task found with ID: ${task_id}`);
+    }
+    if (!block) {
+      // Non-blocking: return current state
+      if (task.status !== 'running' && task.status !== 'pending') {
+        // Mark as notified
+        updateTaskState(task_id, toolUseContext.setAppState, t => ({
+          ...t,
+          notified: true
+        }));
+        return {
+          data: {
+            retrieval_status: 'success' as const,
+            task: await getTaskOutputData(task)
+          }
+        };
+      }
+      return {
+        data: {
+          retrieval_status: 'not_ready' as const,
+          task: await getTaskOutputData(task)
+        }
+      };
+    }
+
+    // Blocking: wait for completion
+    if (onProgress) {
+      onProgress({
+        toolUseID: `task-output-waiting-${Date.now()}`,
+        data: {
+          type: 'waiting_for_task',
+          taskDescription: task.description,
+          taskType: task.type
+        }
+      });
+    }
+    const completedTask = await waitForTaskCompletion(task_id, toolUseContext.getAppState, timeout, toolUseContext.abortController);
+    if (!completedTask) {
+      return {
+        data: {
+          retrieval_status: 'timeout' as const,
+          task: null
+        }
+      };
+    }
+    if (completedTask.status === 'running' || completedTask.status === 'pending') {
+      return {
+        data: {
+          retrieval_status: 'timeout' as const,
+          task: await getTaskOutputData(completedTask)
+        }
+      };
+    }
+
+    // Mark as notified
+    updateTaskState(task_id, toolUseContext.setAppState, t => ({
+      ...t,
+      notified: true
+    }));
+    return {
+      data: {
+        retrieval_status: 'success' as const,
+        task: await getTaskOutputData(completedTask)
+      }
+    };
+  },
+  mapToolResultToToolResultBlockParam(data, toolUseID) {
+    const parts: string[] = [];
+    parts.push(`<retrieval_status>${data.retrieval_status}</retrieval_status>`);
+    if (data.task) {
+      parts.push(`<task_id>${data.task.task_id}</task_id>`);
+      parts.push(`<task_type>${data.task.task_type}</task_type>`);
+      parts.push(`<status>${data.task.status}</status>`);
+      if (data.task.exitCode !== undefined && data.task.exitCode !== null) {
+        parts.push(`<exit_code>${data.task.exitCode}</exit_code>`);
+      }
+      if (data.task.output?.trim()) {
+        const {
+          content
+        } = formatTaskOutput(data.task.output, data.task.task_id);
+        parts.push(`<output>\n${content.trimEnd()}\n</output>`);
+      }
+      if (data.task.error) {
+        parts.push(`<error>${data.task.error}</error>`);
+      }
+    }
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result' as const,
+      content: parts.join('\n\n')
+    };
+  },
+  renderToolUseMessage(input) {
+    const {
+      block = true
+    } = input;
+    if (!block) {
+      return 'non-blocking';
+    }
+    return '';
+  },
+  renderToolUseTag(input) {
+    if (!input.task_id) {
+      return null;
+    }
+    return <Text dimColor> {input.task_id}</Text>;
+  },
+  renderToolUseProgressMessage(progressMessages) {
+    const lastProgress = progressMessages[progressMessages.length - 1];
+    const progressData = lastProgress?.data as {
+      taskDescription?: string;
+      taskType?: string;
+    } | undefined;
+    return <Box flexDirection="column">
+          {progressData?.taskDescription && <Text>&nbsp;&nbsp;{progressData.taskDescription}</Text>}
+          <Text>
+            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Waiting for task{' '}
+            <Text dimColor>(esc to give additional instructions)</Text>
+          </Text>
+        </Box>;
+  },
+  renderToolResultMessage(content, _, {
+    verbose,
+    theme
+  }) {
+    return <TaskOutputResultDisplay content={content} verbose={verbose} theme={theme} />;
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />;
+  },
+  renderToolUseErrorMessage(result, {
+    verbose
+  }) {
+    return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
+  }
+} satisfies ToolDef<InputSchema, TaskOutputToolOutput>);
+function TaskOutputResultDisplay(t0) {
+  const $ = _c(54);
+  const {
+    content,
+    verbose: t1,
+    theme
+  } = t0;
+  const verbose = t1 === undefined ? false : t1;
+  const expandShortcut = useShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
+  let t2;
+  if ($[0] !== content) {
+    t2 = typeof content === "string" ? jsonParse(content) : content;
+    $[0] = content;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const result = t2;
+  if (!result.task) {
+    let t3;
+    if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+      t3 = <MessageResponse><Text dimColor={true}>No task output available</Text></MessageResponse>;
+      $[2] = t3;
+    } else {
+      t3 = $[2];
+    }
+    return t3;
+  }
+  const {
+    task
+  } = result;
+  if (task.task_type === "local_bash") {
+    let t3;
+    if ($[3] !== task.error || $[4] !== task.output) {
+      t3 = {
+        stdout: task.output,
+        stderr: "",
+        isImage: false,
+        dangerouslyDisableSandbox: true,
+        returnCodeInterpretation: task.error
+      };
+      $[3] = task.error;
+      $[4] = task.output;
+      $[5] = t3;
+    } else {
+      t3 = $[5];
+    }
+    const bashOut = t3;
+    let t4;
+    if ($[6] !== bashOut || $[7] !== verbose) {
+      t4 = <BashToolResultMessage content={bashOut} verbose={verbose} />;
+      $[6] = bashOut;
+      $[7] = verbose;
+      $[8] = t4;
+    } else {
+      t4 = $[8];
+    }
+    return t4;
+  }
+  if (task.task_type === "local_agent") {
+    const lineCount = task.result ? countCharInString(task.result, "\n") + 1 : 0;
+    if (result.retrieval_status === "success") {
+      if (verbose) {
+        let t3;
+        if ($[9] !== lineCount || $[10] !== task.description) {
+          t3 = <Text>{task.description} ({lineCount} lines)</Text>;
+          $[9] = lineCount;
+          $[10] = task.description;
+          $[11] = t3;
+        } else {
+          t3 = $[11];
+        }
+        let t4;
+        if ($[12] !== task.prompt || $[13] !== theme) {
+          t4 = task.prompt && <AgentPromptDisplay prompt={task.prompt} theme={theme} dim={true} />;
+          $[12] = task.prompt;
+          $[13] = theme;
+          $[14] = t4;
+        } else {
+          t4 = $[14];
+        }
+        let t5;
+        if ($[15] !== task.result || $[16] !== theme) {
+          t5 = task.result && <Box marginTop={1}><AgentResponseDisplay content={[{
+              type: "text",
+              text: task.result
+            }]} theme={theme} /></Box>;
+          $[15] = task.result;
+          $[16] = theme;
+          $[17] = t5;
+        } else {
+          t5 = $[17];
+        }
+        let t6;
+        if ($[18] !== task.error) {
+          t6 = task.error && <Box flexDirection="column" marginTop={1}><Text color="error" bold={true}>Error:</Text><Box paddingLeft={2}><Text color="error">{task.error}</Text></Box></Box>;
+          $[18] = task.error;
+          $[19] = t6;
+        } else {
+          t6 = $[19];
+        }
+        let t7;
+        if ($[20] !== t4 || $[21] !== t5 || $[22] !== t6) {
+          t7 = <Box flexDirection="column" paddingLeft={2} marginTop={1}>{t4}{t5}{t6}</Box>;
+          $[20] = t4;
+          $[21] = t5;
+          $[22] = t6;
+          $[23] = t7;
+        } else {
+          t7 = $[23];
+        }
+        let t8;
+        if ($[24] !== t3 || $[25] !== t7) {
+          t8 = <Box flexDirection="column">{t3}{t7}</Box>;
+          $[24] = t3;
+          $[25] = t7;
+          $[26] = t8;
+        } else {
+          t8 = $[26];
+        }
+        return t8;
+      }
+      let t3;
+      if ($[27] !== expandShortcut) {
+        t3 = <MessageResponse><Text dimColor={true}>Read output ({expandShortcut} to expand)</Text></MessageResponse>;
+        $[27] = expandShortcut;
+        $[28] = t3;
+      } else {
+        t3 = $[28];
+      }
+      return t3;
+    }
+    if (result.retrieval_status === "timeout" || task.status === "running") {
+      let t3;
+      if ($[29] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = <MessageResponse><Text dimColor={true}>Task is still running…</Text></MessageResponse>;
+        $[29] = t3;
+      } else {
+        t3 = $[29];
+      }
+      return t3;
+    }
+    if (result.retrieval_status === "not_ready") {
+      let t3;
+      if ($[30] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = <MessageResponse><Text dimColor={true}>Task is still running…</Text></MessageResponse>;
+        $[30] = t3;
+      } else {
+        t3 = $[30];
+      }
+      return t3;
+    }
+    let t3;
+    if ($[31] === Symbol.for("react.memo_cache_sentinel")) {
+      t3 = <MessageResponse><Text dimColor={true}>Task not ready</Text></MessageResponse>;
+      $[31] = t3;
+    } else {
+      t3 = $[31];
+    }
+    return t3;
+  }
+  if (task.task_type === "remote_agent") {
+    let t3;
+    if ($[32] !== task.description || $[33] !== task.status) {
+      t3 = <Text>  {task.description} [{task.status}]</Text>;
+      $[32] = task.description;
+      $[33] = task.status;
+      $[34] = t3;
+    } else {
+      t3 = $[34];
+    }
+    let t4;
+    if ($[35] !== task.output || $[36] !== verbose) {
+      t4 = task.output && verbose && <Box paddingLeft={4} marginTop={1}><Text>{task.output}</Text></Box>;
+      $[35] = task.output;
+      $[36] = verbose;
+      $[37] = t4;
+    } else {
+      t4 = $[37];
+    }
+    let t5;
+    if ($[38] !== expandShortcut || $[39] !== task.output || $[40] !== verbose) {
+      t5 = !verbose && task.output && <Text dimColor={true}>{"     "}({expandShortcut} to expand)</Text>;
+      $[38] = expandShortcut;
+      $[39] = task.output;
+      $[40] = verbose;
+      $[41] = t5;
+    } else {
+      t5 = $[41];
+    }
+    let t6;
+    if ($[42] !== t3 || $[43] !== t4 || $[44] !== t5) {
+      t6 = <Box flexDirection="column">{t3}{t4}{t5}</Box>;
+      $[42] = t3;
+      $[43] = t4;
+      $[44] = t5;
+      $[45] = t6;
+    } else {
+      t6 = $[45];
+    }
+    return t6;
+  }
+  let t3;
+  if ($[46] !== task.description || $[47] !== task.status) {
+    t3 = <Text>  {task.description} [{task.status}]</Text>;
+    $[46] = task.description;
+    $[47] = task.status;
+    $[48] = t3;
+  } else {
+    t3 = $[48];
+  }
+  let t4;
+  if ($[49] !== task.output) {
+    t4 = task.output && <Box paddingLeft={4}><Text>{task.output.slice(0, 500)}</Text></Box>;
+    $[49] = task.output;
+    $[50] = t4;
+  } else {
+    t4 = $[50];
+  }
+  let t5;
+  if ($[51] !== t3 || $[52] !== t4) {
+    t5 = <Box flexDirection="column">{t3}{t4}</Box>;
+    $[51] = t3;
+    $[52] = t4;
+    $[53] = t5;
+  } else {
+    t5 = $[53];
+  }
+  return t5;
+}
+export default TaskOutputTool;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","z","FallbackToolUseErrorMessage","FallbackToolUseRejectedMessage","MessageResponse","Box","Text","useShortcutDisplay","TaskType","Tool","buildTool","ToolDef","LocalAgentTaskState","LocalShellTaskState","RemoteAgentTaskState","TaskState","AbortError","lazySchema","extractTextContent","semanticBoolean","sleep","jsonParse","countCharInString","getTaskOutput","updateTaskState","formatTaskOutput","ThemeName","AgentPromptDisplay","AgentResponseDisplay","BashToolResultMessage","TASK_OUTPUT_TOOL_NAME","inputSchema","strictObject","task_id","string","describe","block","boolean","default","timeout","number","min","max","InputSchema","ReturnType","TaskOutputToolInput","infer","TaskOutput","task_type","status","description","output","exitCode","error","prompt","result","TaskOutputToolOutput","retrieval_status","task","TaskOutputProgress","Progress","getTaskOutputData","Promise","type","bashTask","taskOutputObj","shellCommand","taskOutput","stdout","getStdout","stderr","getStderr","filter","Boolean","join","id","baseOutput","code","agentTask","cleanResult","content","undefined","remoteTask","command","waitForTaskCompletion","taskId","getAppState","tasks","Record","timeoutMs","abortController","AbortController","startTime","Date","now","signal","aborted","state","finalState","TaskOutputTool","name","searchHint","maxResultSizeChars","shouldDefer","aliases","userFacingName","isConcurrencySafe","_input","isReadOnly","isEnabled","toAutoClassifierInput","input","validateInput","message","errorCode","appState","call","toolUseContext","_canUseTool","_parentMessage","onProgress","Error","setAppState","t","notified","data","const","toolUseID","taskDescription","taskType","completedTask","mapToolResultToToolResultBlockParam","parts","push","trim","trimEnd","tool_use_id","renderToolUseMessage","renderToolUseTag","renderToolUseProgressMessage","progressMessages","lastProgress","length","progressData","renderToolResultMessage","_","verbose","theme","renderToolUseRejectedMessage","renderToolUseErrorMessage","TaskOutputResultDisplay","t0","$","_c","t1","expandShortcut","t2","t3","Symbol","for","isImage","dangerouslyDisableSandbox","returnCodeInterpretation","bashOut","t4","lineCount","t5","text","t6","t7","t8","slice"],"sources":["TaskOutputTool.tsx"],"sourcesContent":["import React from 'react'\nimport { z } from 'zod/v4'\nimport { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js'\nimport { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { Box, Text } from '../../ink.js'\nimport { useShortcutDisplay } from '../../keybindings/useShortcutDisplay.js'\nimport type { TaskType } from '../../Task.js'\nimport type { Tool } from '../../Tool.js'\nimport { buildTool, type ToolDef } from '../../Tool.js'\nimport type { LocalAgentTaskState } from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport type { LocalShellTaskState } from '../../tasks/LocalShellTask/guards.js'\nimport type { RemoteAgentTaskState } from '../../tasks/RemoteAgentTask/RemoteAgentTask.js'\nimport type { TaskState } from '../../tasks/types.js'\nimport { AbortError } from '../../utils/errors.js'\nimport { lazySchema } from '../../utils/lazySchema.js'\nimport { extractTextContent } from '../../utils/messages.js'\nimport { semanticBoolean } from '../../utils/semanticBoolean.js'\nimport { sleep } from '../../utils/sleep.js'\nimport { jsonParse } from '../../utils/slowOperations.js'\nimport { countCharInString } from '../../utils/stringUtils.js'\nimport { getTaskOutput } from '../../utils/task/diskOutput.js'\nimport { updateTaskState } from '../../utils/task/framework.js'\nimport { formatTaskOutput } from '../../utils/task/outputFormatting.js'\nimport type { ThemeName } from '../../utils/theme.js'\nimport { AgentPromptDisplay, AgentResponseDisplay } from '../AgentTool/UI.js'\nimport BashToolResultMessage from '../BashTool/BashToolResultMessage.js'\nimport { TASK_OUTPUT_TOOL_NAME } from './constants.js'\n\nconst inputSchema = lazySchema(() =>\n  z.strictObject({\n    task_id: z.string().describe('The task ID to get output from'),\n    block: semanticBoolean(z.boolean().default(true)).describe(\n      'Whether to wait for completion',\n    ),\n    timeout: z\n      .number()\n      .min(0)\n      .max(600000)\n      .default(30000)\n      .describe('Max wait time in ms'),\n  }),\n)\ntype InputSchema = ReturnType<typeof inputSchema>\n\ntype TaskOutputToolInput = z.infer<InputSchema>\n\n// Unified output type covering all task types\ntype TaskOutput = {\n  task_id: string\n  task_type: TaskType\n  status: string\n  description: string\n  output: string\n  exitCode?: number | null\n  error?: string\n  // For agents\n  prompt?: string\n  result?: string\n}\n\ntype TaskOutputToolOutput = {\n  retrieval_status: 'success' | 'timeout' | 'not_ready'\n  task: TaskOutput | null\n}\n\n// Re-export Progress from centralized types to break import cycles\nexport type { TaskOutputProgress as Progress } from '../../types/tools.js'\n\n// Get output for any task type\nasync function getTaskOutputData(task: TaskState): Promise<TaskOutput> {\n  let output: string\n  if (task.type === 'local_bash') {\n    const bashTask = task as LocalShellTaskState\n    const taskOutputObj = bashTask.shellCommand?.taskOutput\n    if (taskOutputObj) {\n      const stdout = await taskOutputObj.getStdout()\n      const stderr = taskOutputObj.getStderr()\n      output = [stdout, stderr].filter(Boolean).join('\\n')\n    } else {\n      output = await getTaskOutput(task.id)\n    }\n  } else {\n    output = await getTaskOutput(task.id)\n  }\n\n  const baseOutput: TaskOutput = {\n    task_id: task.id,\n    task_type: task.type,\n    status: task.status,\n    description: task.description,\n    output,\n  }\n\n  // Add type-specific fields\n  if (task.type === 'local_bash') {\n    const bashTask = task as LocalShellTaskState\n    return {\n      ...baseOutput,\n      exitCode: bashTask.result?.code ?? null,\n    }\n  }\n\n  if (task.type === 'local_agent') {\n    const agentTask = task as LocalAgentTaskState\n    // Prefer the clean final answer from the in-memory result over the raw\n    // JSONL transcript on disk. The disk output is a symlink to the full\n    // session transcript (every message, tool use, etc.), not just the\n    // subagent's answer. The in-memory result contains only the final\n    // assistant text content blocks.\n    const cleanResult = agentTask.result\n      ? extractTextContent(agentTask.result.content, '\\n')\n      : undefined\n    return {\n      ...baseOutput,\n      prompt: agentTask.prompt,\n      result: cleanResult || output,\n      output: cleanResult || output,\n      error: agentTask.error,\n    }\n  }\n\n  if (task.type === 'remote_agent') {\n    const remoteTask = task as RemoteAgentTaskState\n    return {\n      ...baseOutput,\n      prompt: remoteTask.command,\n    }\n  }\n\n  return baseOutput\n}\n\n// Wait for task to complete\nasync function waitForTaskCompletion(\n  taskId: string,\n  getAppState: () => { tasks?: Record<string, TaskState> },\n  timeoutMs: number,\n  abortController?: AbortController,\n): Promise<TaskState | null> {\n  const startTime = Date.now()\n\n  while (Date.now() - startTime < timeoutMs) {\n    // Check abort signal\n    if (abortController?.signal.aborted) {\n      throw new AbortError()\n    }\n\n    const state = getAppState()\n    const task = state.tasks?.[taskId] as TaskState | undefined\n\n    if (!task) {\n      return null\n    }\n\n    if (task.status !== 'running' && task.status !== 'pending') {\n      return task\n    }\n\n    // Wait before polling again\n    await sleep(100)\n  }\n\n  // Timeout - return current state\n  const finalState = getAppState()\n  return (finalState.tasks?.[taskId] as TaskState) ?? null\n}\n\nexport const TaskOutputTool: Tool<InputSchema, TaskOutputToolOutput> =\n  buildTool({\n    name: TASK_OUTPUT_TOOL_NAME,\n    searchHint: 'read output/logs from a background task',\n    maxResultSizeChars: 100_000,\n    shouldDefer: true,\n    // Backwards-compatible aliases for renamed tools\n    aliases: ['AgentOutputTool', 'BashOutputTool'],\n\n    userFacingName() {\n      return 'Task Output'\n    },\n\n    get inputSchema(): InputSchema {\n      return inputSchema()\n    },\n\n    async description() {\n      return '[Deprecated] — prefer Read on the task output file path'\n    },\n\n    isConcurrencySafe(_input) {\n      return this.isReadOnly?.(_input) ?? false\n    },\n\n    isEnabled() {\n      return \"external\" !== 'ant'\n    },\n\n    isReadOnly(_input) {\n      return true\n    },\n    toAutoClassifierInput(input) {\n      return input.task_id\n    },\n\n    async prompt() {\n      return `DEPRECATED: Prefer using the Read tool on the task's output file path instead. Background tasks return their output file path in the tool result, and you receive a <task-notification> with the same path when the task completes — Read that file directly.\n\n- Retrieves output from a running or completed task (background shell, agent, or remote session)\n- Takes a task_id parameter identifying the task\n- Returns the task output along with status information\n- Use block=true (default) to wait for task completion\n- Use block=false for non-blocking check of current status\n- Task IDs can be found using the /tasks command\n- Works with all task types: background shells, async agents, and remote sessions`\n    },\n\n    async validateInput({ task_id }, { getAppState }) {\n      if (!task_id) {\n        return {\n          result: false,\n          message: 'Task ID is required',\n          errorCode: 1,\n        }\n      }\n\n      const appState = getAppState()\n      const task = appState.tasks?.[task_id] as TaskState | undefined\n\n      if (!task) {\n        return {\n          result: false,\n          message: `No task found with ID: ${task_id}`,\n          errorCode: 2,\n        }\n      }\n\n      return { result: true }\n    },\n\n    async call(\n      input: TaskOutputToolInput,\n      toolUseContext,\n      _canUseTool,\n      _parentMessage,\n      onProgress,\n    ) {\n      const { task_id, block, timeout } = input\n\n      const appState = toolUseContext.getAppState()\n      const task = appState.tasks?.[task_id] as TaskState | undefined\n\n      if (!task) {\n        throw new Error(`No task found with ID: ${task_id}`)\n      }\n\n      if (!block) {\n        // Non-blocking: return current state\n        if (task.status !== 'running' && task.status !== 'pending') {\n          // Mark as notified\n          updateTaskState(task_id, toolUseContext.setAppState, t => ({\n            ...t,\n            notified: true,\n          }))\n          return {\n            data: {\n              retrieval_status: 'success' as const,\n              task: await getTaskOutputData(task),\n            },\n          }\n        }\n        return {\n          data: {\n            retrieval_status: 'not_ready' as const,\n            task: await getTaskOutputData(task),\n          },\n        }\n      }\n\n      // Blocking: wait for completion\n      if (onProgress) {\n        onProgress({\n          toolUseID: `task-output-waiting-${Date.now()}`,\n          data: {\n            type: 'waiting_for_task',\n            taskDescription: task.description,\n            taskType: task.type,\n          },\n        })\n      }\n\n      const completedTask = await waitForTaskCompletion(\n        task_id,\n        toolUseContext.getAppState,\n        timeout,\n        toolUseContext.abortController,\n      )\n\n      if (!completedTask) {\n        return {\n          data: {\n            retrieval_status: 'timeout' as const,\n            task: null,\n          },\n        }\n      }\n\n      if (\n        completedTask.status === 'running' ||\n        completedTask.status === 'pending'\n      ) {\n        return {\n          data: {\n            retrieval_status: 'timeout' as const,\n            task: await getTaskOutputData(completedTask),\n          },\n        }\n      }\n\n      // Mark as notified\n      updateTaskState(task_id, toolUseContext.setAppState, t => ({\n        ...t,\n        notified: true,\n      }))\n\n      return {\n        data: {\n          retrieval_status: 'success' as const,\n          task: await getTaskOutputData(completedTask),\n        },\n      }\n    },\n\n    mapToolResultToToolResultBlockParam(data, toolUseID) {\n      const parts: string[] = []\n\n      parts.push(\n        `<retrieval_status>${data.retrieval_status}</retrieval_status>`,\n      )\n\n      if (data.task) {\n        parts.push(`<task_id>${data.task.task_id}</task_id>`)\n        parts.push(`<task_type>${data.task.task_type}</task_type>`)\n        parts.push(`<status>${data.task.status}</status>`)\n\n        if (data.task.exitCode !== undefined && data.task.exitCode !== null) {\n          parts.push(`<exit_code>${data.task.exitCode}</exit_code>`)\n        }\n\n        if (data.task.output?.trim()) {\n          const { content } = formatTaskOutput(\n            data.task.output,\n            data.task.task_id,\n          )\n          parts.push(`<output>\\n${content.trimEnd()}\\n</output>`)\n        }\n\n        if (data.task.error) {\n          parts.push(`<error>${data.task.error}</error>`)\n        }\n      }\n\n      return {\n        tool_use_id: toolUseID,\n        type: 'tool_result' as const,\n        content: parts.join('\\n\\n'),\n      }\n    },\n\n    renderToolUseMessage(input) {\n      const { block = true } = input\n      if (!block) {\n        return 'non-blocking'\n      }\n      return ''\n    },\n\n    renderToolUseTag(input) {\n      if (!input.task_id) {\n        return null\n      }\n      return <Text dimColor> {input.task_id}</Text>\n    },\n\n    renderToolUseProgressMessage(progressMessages) {\n      const lastProgress = progressMessages[progressMessages.length - 1]\n      const progressData = lastProgress?.data as\n        | { taskDescription?: string; taskType?: string }\n        | undefined\n\n      return (\n        <Box flexDirection=\"column\">\n          {progressData?.taskDescription && (\n            <Text>&nbsp;&nbsp;{progressData.taskDescription}</Text>\n          )}\n          <Text>\n            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Waiting for task{' '}\n            <Text dimColor>(esc to give additional instructions)</Text>\n          </Text>\n        </Box>\n      )\n    },\n\n    renderToolResultMessage(content, _, { verbose, theme }) {\n      return (\n        <TaskOutputResultDisplay\n          content={content}\n          verbose={verbose}\n          theme={theme}\n        />\n      )\n    },\n\n    renderToolUseRejectedMessage() {\n      return <FallbackToolUseRejectedMessage />\n    },\n\n    renderToolUseErrorMessage(result, { verbose }) {\n      return <FallbackToolUseErrorMessage result={result} verbose={verbose} />\n    },\n  } satisfies ToolDef<InputSchema, TaskOutputToolOutput>)\n\nfunction TaskOutputResultDisplay({\n  content,\n  verbose = false,\n  theme,\n}: {\n  content: string | TaskOutputToolOutput\n  verbose?: boolean\n  theme: ThemeName\n}): React.ReactNode {\n  const expandShortcut = useShortcutDisplay(\n    'app:toggleTranscript',\n    'Global',\n    'ctrl+o',\n  )\n  const result: TaskOutputToolOutput =\n    typeof content === 'string' ? jsonParse(content) : content\n\n  if (!result.task) {\n    return (\n      <MessageResponse>\n        <Text dimColor>No task output available</Text>\n      </MessageResponse>\n    )\n  }\n\n  const { task } = result\n\n  // For shell tasks, render like BashToolResultMessage\n  if (task.task_type === 'local_bash') {\n    const bashOut = {\n      stdout: task.output,\n      stderr: '',\n      isImage: false,\n      dangerouslyDisableSandbox: true,\n      returnCodeInterpretation: task.error,\n    }\n    return <BashToolResultMessage content={bashOut} verbose={verbose} />\n  }\n\n  // For agent tasks, render with prompt/response display\n  if (task.task_type === 'local_agent') {\n    const lineCount = task.result ? countCharInString(task.result, '\\n') + 1 : 0\n\n    if (result.retrieval_status === 'success') {\n      if (verbose) {\n        return (\n          <Box flexDirection=\"column\">\n            <Text>\n              {task.description} ({lineCount} lines)\n            </Text>\n            <Box flexDirection=\"column\" paddingLeft={2} marginTop={1}>\n              {task.prompt && (\n                <AgentPromptDisplay prompt={task.prompt} theme={theme} dim />\n              )}\n              {task.result && (\n                <Box marginTop={1}>\n                  <AgentResponseDisplay\n                    content={[{ type: 'text', text: task.result }]}\n                    theme={theme}\n                  />\n                </Box>\n              )}\n              {task.error && (\n                <Box flexDirection=\"column\" marginTop={1}>\n                  <Text color=\"error\" bold>\n                    Error:\n                  </Text>\n                  <Box paddingLeft={2}>\n                    <Text color=\"error\">{task.error}</Text>\n                  </Box>\n                </Box>\n              )}\n            </Box>\n          </Box>\n        )\n      }\n      return (\n        <MessageResponse>\n          <Text dimColor>Read output ({expandShortcut} to expand)</Text>\n        </MessageResponse>\n      )\n    }\n\n    if (result.retrieval_status === 'timeout' || task.status === 'running') {\n      return (\n        <MessageResponse>\n          <Text dimColor>Task is still running…</Text>\n        </MessageResponse>\n      )\n    }\n\n    if (result.retrieval_status === 'not_ready') {\n      return (\n        <MessageResponse>\n          <Text dimColor>Task is still running…</Text>\n        </MessageResponse>\n      )\n    }\n\n    return (\n      <MessageResponse>\n        <Text dimColor>Task not ready</Text>\n      </MessageResponse>\n    )\n  }\n\n  // For remote agent tasks\n  if (task.task_type === 'remote_agent') {\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          &nbsp;&nbsp;{task.description} [{task.status}]\n        </Text>\n        {task.output && verbose && (\n          <Box paddingLeft={4} marginTop={1}>\n            <Text>{task.output}</Text>\n          </Box>\n        )}\n        {!verbose && task.output && (\n          <Text dimColor>\n            {'     '}({expandShortcut} to expand)\n          </Text>\n        )}\n      </Box>\n    )\n  }\n\n  // Default rendering\n  return (\n    <Box flexDirection=\"column\">\n      <Text>\n        &nbsp;&nbsp;{task.description} [{task.status}]\n      </Text>\n      {task.output && (\n        <Box paddingLeft={4}>\n          <Text>{task.output.slice(0, 500)}</Text>\n        </Box>\n      )}\n    </Box>\n  )\n}\n\nexport default TaskOutputTool\n"],"mappings":";AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,CAAC,QAAQ,QAAQ;AAC1B,SAASC,2BAA2B,QAAQ,iDAAiD;AAC7F,SAASC,8BAA8B,QAAQ,oDAAoD;AACnG,SAASC,eAAe,QAAQ,qCAAqC;AACrE,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAc;AACxC,SAASC,kBAAkB,QAAQ,yCAAyC;AAC5E,cAAcC,QAAQ,QAAQ,eAAe;AAC7C,cAAcC,IAAI,QAAQ,eAAe;AACzC,SAASC,SAAS,EAAE,KAAKC,OAAO,QAAQ,eAAe;AACvD,cAAcC,mBAAmB,QAAQ,8CAA8C;AACvF,cAAcC,mBAAmB,QAAQ,sCAAsC;AAC/E,cAAcC,oBAAoB,QAAQ,gDAAgD;AAC1F,cAAcC,SAAS,QAAQ,sBAAsB;AACrD,SAASC,UAAU,QAAQ,uBAAuB;AAClD,SAASC,UAAU,QAAQ,2BAA2B;AACtD,SAASC,kBAAkB,QAAQ,yBAAyB;AAC5D,SAASC,eAAe,QAAQ,gCAAgC;AAChE,SAASC,KAAK,QAAQ,sBAAsB;AAC5C,SAASC,SAAS,QAAQ,+BAA+B;AACzD,SAASC,iBAAiB,QAAQ,4BAA4B;AAC9D,SAASC,aAAa,QAAQ,gCAAgC;AAC9D,SAASC,eAAe,QAAQ,+BAA+B;AAC/D,SAASC,gBAAgB,QAAQ,sCAAsC;AACvE,cAAcC,SAAS,QAAQ,sBAAsB;AACrD,SAASC,kBAAkB,EAAEC,oBAAoB,QAAQ,oBAAoB;AAC7E,OAAOC,qBAAqB,MAAM,sCAAsC;AACxE,SAASC,qBAAqB,QAAQ,gBAAgB;AAEtD,MAAMC,WAAW,GAAGd,UAAU,CAAC,MAC7BhB,CAAC,CAAC+B,YAAY,CAAC;EACbC,OAAO,EAAEhC,CAAC,CAACiC,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,gCAAgC,CAAC;EAC9DC,KAAK,EAAEjB,eAAe,CAAClB,CAAC,CAACoC,OAAO,CAAC,CAAC,CAACC,OAAO,CAAC,IAAI,CAAC,CAAC,CAACH,QAAQ,CACxD,gCACF,CAAC;EACDI,OAAO,EAAEtC,CAAC,CACPuC,MAAM,CAAC,CAAC,CACRC,GAAG,CAAC,CAAC,CAAC,CACNC,GAAG,CAAC,MAAM,CAAC,CACXJ,OAAO,CAAC,KAAK,CAAC,CACdH,QAAQ,CAAC,qBAAqB;AACnC,CAAC,CACH,CAAC;AACD,KAAKQ,WAAW,GAAGC,UAAU,CAAC,OAAOb,WAAW,CAAC;AAEjD,KAAKc,mBAAmB,GAAG5C,CAAC,CAAC6C,KAAK,CAACH,WAAW,CAAC;;AAE/C;AACA,KAAKI,UAAU,GAAG;EAChBd,OAAO,EAAE,MAAM;EACfe,SAAS,EAAExC,QAAQ;EACnByC,MAAM,EAAE,MAAM;EACdC,WAAW,EAAE,MAAM;EACnBC,MAAM,EAAE,MAAM;EACdC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;EACxBC,KAAK,CAAC,EAAE,MAAM;EACd;EACAC,MAAM,CAAC,EAAE,MAAM;EACfC,MAAM,CAAC,EAAE,MAAM;AACjB,CAAC;AAED,KAAKC,oBAAoB,GAAG;EAC1BC,gBAAgB,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW;EACrDC,IAAI,EAAEX,UAAU,GAAG,IAAI;AACzB,CAAC;;AAED;AACA,cAAcY,kBAAkB,IAAIC,QAAQ,QAAQ,sBAAsB;;AAE1E;AACA,eAAeC,iBAAiBA,CAACH,IAAI,EAAE3C,SAAS,CAAC,EAAE+C,OAAO,CAACf,UAAU,CAAC,CAAC;EACrE,IAAII,MAAM,EAAE,MAAM;EAClB,IAAIO,IAAI,CAACK,IAAI,KAAK,YAAY,EAAE;IAC9B,MAAMC,QAAQ,GAAGN,IAAI,IAAI7C,mBAAmB;IAC5C,MAAMoD,aAAa,GAAGD,QAAQ,CAACE,YAAY,EAAEC,UAAU;IACvD,IAAIF,aAAa,EAAE;MACjB,MAAMG,MAAM,GAAG,MAAMH,aAAa,CAACI,SAAS,CAAC,CAAC;MAC9C,MAAMC,MAAM,GAAGL,aAAa,CAACM,SAAS,CAAC,CAAC;MACxCpB,MAAM,GAAG,CAACiB,MAAM,EAAEE,MAAM,CAAC,CAACE,MAAM,CAACC,OAAO,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;IACtD,CAAC,MAAM;MACLvB,MAAM,GAAG,MAAM5B,aAAa,CAACmC,IAAI,CAACiB,EAAE,CAAC;IACvC;EACF,CAAC,MAAM;IACLxB,MAAM,GAAG,MAAM5B,aAAa,CAACmC,IAAI,CAACiB,EAAE,CAAC;EACvC;EAEA,MAAMC,UAAU,EAAE7B,UAAU,GAAG;IAC7Bd,OAAO,EAAEyB,IAAI,CAACiB,EAAE;IAChB3B,SAAS,EAAEU,IAAI,CAACK,IAAI;IACpBd,MAAM,EAAES,IAAI,CAACT,MAAM;IACnBC,WAAW,EAAEQ,IAAI,CAACR,WAAW;IAC7BC;EACF,CAAC;;EAED;EACA,IAAIO,IAAI,CAACK,IAAI,KAAK,YAAY,EAAE;IAC9B,MAAMC,QAAQ,GAAGN,IAAI,IAAI7C,mBAAmB;IAC5C,OAAO;MACL,GAAG+D,UAAU;MACbxB,QAAQ,EAAEY,QAAQ,CAACT,MAAM,EAAEsB,IAAI,IAAI;IACrC,CAAC;EACH;EAEA,IAAInB,IAAI,CAACK,IAAI,KAAK,aAAa,EAAE;IAC/B,MAAMe,SAAS,GAAGpB,IAAI,IAAI9C,mBAAmB;IAC7C;IACA;IACA;IACA;IACA;IACA,MAAMmE,WAAW,GAAGD,SAAS,CAACvB,MAAM,GAChCrC,kBAAkB,CAAC4D,SAAS,CAACvB,MAAM,CAACyB,OAAO,EAAE,IAAI,CAAC,GAClDC,SAAS;IACb,OAAO;MACL,GAAGL,UAAU;MACbtB,MAAM,EAAEwB,SAAS,CAACxB,MAAM;MACxBC,MAAM,EAAEwB,WAAW,IAAI5B,MAAM;MAC7BA,MAAM,EAAE4B,WAAW,IAAI5B,MAAM;MAC7BE,KAAK,EAAEyB,SAAS,CAACzB;IACnB,CAAC;EACH;EAEA,IAAIK,IAAI,CAACK,IAAI,KAAK,cAAc,EAAE;IAChC,MAAMmB,UAAU,GAAGxB,IAAI,IAAI5C,oBAAoB;IAC/C,OAAO;MACL,GAAG8D,UAAU;MACbtB,MAAM,EAAE4B,UAAU,CAACC;IACrB,CAAC;EACH;EAEA,OAAOP,UAAU;AACnB;;AAEA;AACA,eAAeQ,qBAAqBA,CAClCC,MAAM,EAAE,MAAM,EACdC,WAAW,EAAE,GAAG,GAAG;EAAEC,KAAK,CAAC,EAAEC,MAAM,CAAC,MAAM,EAAEzE,SAAS,CAAC;AAAC,CAAC,EACxD0E,SAAS,EAAE,MAAM,EACjBC,eAAiC,CAAjB,EAAEC,eAAe,CAClC,EAAE7B,OAAO,CAAC/C,SAAS,GAAG,IAAI,CAAC,CAAC;EAC3B,MAAM6E,SAAS,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;EAE5B,OAAOD,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF,SAAS,GAAGH,SAAS,EAAE;IACzC;IACA,IAAIC,eAAe,EAAEK,MAAM,CAACC,OAAO,EAAE;MACnC,MAAM,IAAIhF,UAAU,CAAC,CAAC;IACxB;IAEA,MAAMiF,KAAK,GAAGX,WAAW,CAAC,CAAC;IAC3B,MAAM5B,IAAI,GAAGuC,KAAK,CAACV,KAAK,GAAGF,MAAM,CAAC,IAAItE,SAAS,GAAG,SAAS;IAE3D,IAAI,CAAC2C,IAAI,EAAE;MACT,OAAO,IAAI;IACb;IAEA,IAAIA,IAAI,CAACT,MAAM,KAAK,SAAS,IAAIS,IAAI,CAACT,MAAM,KAAK,SAAS,EAAE;MAC1D,OAAOS,IAAI;IACb;;IAEA;IACA,MAAMtC,KAAK,CAAC,GAAG,CAAC;EAClB;;EAEA;EACA,MAAM8E,UAAU,GAAGZ,WAAW,CAAC,CAAC;EAChC,OAAQY,UAAU,CAACX,KAAK,GAAGF,MAAM,CAAC,IAAItE,SAAS,IAAK,IAAI;AAC1D;AAEA,OAAO,MAAMoF,cAAc,EAAE1F,IAAI,CAACkC,WAAW,EAAEa,oBAAoB,CAAC,GAClE9C,SAAS,CAAC;EACR0F,IAAI,EAAEtE,qBAAqB;EAC3BuE,UAAU,EAAE,yCAAyC;EACrDC,kBAAkB,EAAE,OAAO;EAC3BC,WAAW,EAAE,IAAI;EACjB;EACAC,OAAO,EAAE,CAAC,iBAAiB,EAAE,gBAAgB,CAAC;EAE9CC,cAAcA,CAAA,EAAG;IACf,OAAO,aAAa;EACtB,CAAC;EAED,IAAI1E,WAAWA,CAAA,CAAE,EAAEY,WAAW,CAAC;IAC7B,OAAOZ,WAAW,CAAC,CAAC;EACtB,CAAC;EAED,MAAMmB,WAAWA,CAAA,EAAG;IAClB,OAAO,yDAAyD;EAClE,CAAC;EAEDwD,iBAAiBA,CAACC,MAAM,EAAE;IACxB,OAAO,IAAI,CAACC,UAAU,GAAGD,MAAM,CAAC,IAAI,KAAK;EAC3C,CAAC;EAEDE,SAASA,CAAA,EAAG;IACV,OAAO,UAAU,KAAK,KAAK;EAC7B,CAAC;EAEDD,UAAUA,CAACD,MAAM,EAAE;IACjB,OAAO,IAAI;EACb,CAAC;EACDG,qBAAqBA,CAACC,KAAK,EAAE;IAC3B,OAAOA,KAAK,CAAC9E,OAAO;EACtB,CAAC;EAED,MAAMqB,MAAMA,CAAA,EAAG;IACb,OAAO;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF;EAC9E,CAAC;EAED,MAAM0D,aAAaA,CAAC;IAAE/E;EAAQ,CAAC,EAAE;IAAEqD;EAAY,CAAC,EAAE;IAChD,IAAI,CAACrD,OAAO,EAAE;MACZ,OAAO;QACLsB,MAAM,EAAE,KAAK;QACb0D,OAAO,EAAE,qBAAqB;QAC9BC,SAAS,EAAE;MACb,CAAC;IACH;IAEA,MAAMC,QAAQ,GAAG7B,WAAW,CAAC,CAAC;IAC9B,MAAM5B,IAAI,GAAGyD,QAAQ,CAAC5B,KAAK,GAAGtD,OAAO,CAAC,IAAIlB,SAAS,GAAG,SAAS;IAE/D,IAAI,CAAC2C,IAAI,EAAE;MACT,OAAO;QACLH,MAAM,EAAE,KAAK;QACb0D,OAAO,EAAE,0BAA0BhF,OAAO,EAAE;QAC5CiF,SAAS,EAAE;MACb,CAAC;IACH;IAEA,OAAO;MAAE3D,MAAM,EAAE;IAAK,CAAC;EACzB,CAAC;EAED,MAAM6D,IAAIA,CACRL,KAAK,EAAElE,mBAAmB,EAC1BwE,cAAc,EACdC,WAAW,EACXC,cAAc,EACdC,UAAU,EACV;IACA,MAAM;MAAEvF,OAAO;MAAEG,KAAK;MAAEG;IAAQ,CAAC,GAAGwE,KAAK;IAEzC,MAAMI,QAAQ,GAAGE,cAAc,CAAC/B,WAAW,CAAC,CAAC;IAC7C,MAAM5B,IAAI,GAAGyD,QAAQ,CAAC5B,KAAK,GAAGtD,OAAO,CAAC,IAAIlB,SAAS,GAAG,SAAS;IAE/D,IAAI,CAAC2C,IAAI,EAAE;MACT,MAAM,IAAI+D,KAAK,CAAC,0BAA0BxF,OAAO,EAAE,CAAC;IACtD;IAEA,IAAI,CAACG,KAAK,EAAE;MACV;MACA,IAAIsB,IAAI,CAACT,MAAM,KAAK,SAAS,IAAIS,IAAI,CAACT,MAAM,KAAK,SAAS,EAAE;QAC1D;QACAzB,eAAe,CAACS,OAAO,EAAEoF,cAAc,CAACK,WAAW,EAAEC,CAAC,KAAK;UACzD,GAAGA,CAAC;UACJC,QAAQ,EAAE;QACZ,CAAC,CAAC,CAAC;QACH,OAAO;UACLC,IAAI,EAAE;YACJpE,gBAAgB,EAAE,SAAS,IAAIqE,KAAK;YACpCpE,IAAI,EAAE,MAAMG,iBAAiB,CAACH,IAAI;UACpC;QACF,CAAC;MACH;MACA,OAAO;QACLmE,IAAI,EAAE;UACJpE,gBAAgB,EAAE,WAAW,IAAIqE,KAAK;UACtCpE,IAAI,EAAE,MAAMG,iBAAiB,CAACH,IAAI;QACpC;MACF,CAAC;IACH;;IAEA;IACA,IAAI8D,UAAU,EAAE;MACdA,UAAU,CAAC;QACTO,SAAS,EAAE,uBAAuBlC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE;QAC9C+B,IAAI,EAAE;UACJ9D,IAAI,EAAE,kBAAkB;UACxBiE,eAAe,EAAEtE,IAAI,CAACR,WAAW;UACjC+E,QAAQ,EAAEvE,IAAI,CAACK;QACjB;MACF,CAAC,CAAC;IACJ;IAEA,MAAMmE,aAAa,GAAG,MAAM9C,qBAAqB,CAC/CnD,OAAO,EACPoF,cAAc,CAAC/B,WAAW,EAC1B/C,OAAO,EACP8E,cAAc,CAAC3B,eACjB,CAAC;IAED,IAAI,CAACwC,aAAa,EAAE;MAClB,OAAO;QACLL,IAAI,EAAE;UACJpE,gBAAgB,EAAE,SAAS,IAAIqE,KAAK;UACpCpE,IAAI,EAAE;QACR;MACF,CAAC;IACH;IAEA,IACEwE,aAAa,CAACjF,MAAM,KAAK,SAAS,IAClCiF,aAAa,CAACjF,MAAM,KAAK,SAAS,EAClC;MACA,OAAO;QACL4E,IAAI,EAAE;UACJpE,gBAAgB,EAAE,SAAS,IAAIqE,KAAK;UACpCpE,IAAI,EAAE,MAAMG,iBAAiB,CAACqE,aAAa;QAC7C;MACF,CAAC;IACH;;IAEA;IACA1G,eAAe,CAACS,OAAO,EAAEoF,cAAc,CAACK,WAAW,EAAEC,CAAC,KAAK;MACzD,GAAGA,CAAC;MACJC,QAAQ,EAAE;IACZ,CAAC,CAAC,CAAC;IAEH,OAAO;MACLC,IAAI,EAAE;QACJpE,gBAAgB,EAAE,SAAS,IAAIqE,KAAK;QACpCpE,IAAI,EAAE,MAAMG,iBAAiB,CAACqE,aAAa;MAC7C;IACF,CAAC;EACH,CAAC;EAEDC,mCAAmCA,CAACN,IAAI,EAAEE,SAAS,EAAE;IACnD,MAAMK,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;IAE1BA,KAAK,CAACC,IAAI,CACR,qBAAqBR,IAAI,CAACpE,gBAAgB,qBAC5C,CAAC;IAED,IAAIoE,IAAI,CAACnE,IAAI,EAAE;MACb0E,KAAK,CAACC,IAAI,CAAC,YAAYR,IAAI,CAACnE,IAAI,CAACzB,OAAO,YAAY,CAAC;MACrDmG,KAAK,CAACC,IAAI,CAAC,cAAcR,IAAI,CAACnE,IAAI,CAACV,SAAS,cAAc,CAAC;MAC3DoF,KAAK,CAACC,IAAI,CAAC,WAAWR,IAAI,CAACnE,IAAI,CAACT,MAAM,WAAW,CAAC;MAElD,IAAI4E,IAAI,CAACnE,IAAI,CAACN,QAAQ,KAAK6B,SAAS,IAAI4C,IAAI,CAACnE,IAAI,CAACN,QAAQ,KAAK,IAAI,EAAE;QACnEgF,KAAK,CAACC,IAAI,CAAC,cAAcR,IAAI,CAACnE,IAAI,CAACN,QAAQ,cAAc,CAAC;MAC5D;MAEA,IAAIyE,IAAI,CAACnE,IAAI,CAACP,MAAM,EAAEmF,IAAI,CAAC,CAAC,EAAE;QAC5B,MAAM;UAAEtD;QAAQ,CAAC,GAAGvD,gBAAgB,CAClCoG,IAAI,CAACnE,IAAI,CAACP,MAAM,EAChB0E,IAAI,CAACnE,IAAI,CAACzB,OACZ,CAAC;QACDmG,KAAK,CAACC,IAAI,CAAC,aAAarD,OAAO,CAACuD,OAAO,CAAC,CAAC,aAAa,CAAC;MACzD;MAEA,IAAIV,IAAI,CAACnE,IAAI,CAACL,KAAK,EAAE;QACnB+E,KAAK,CAACC,IAAI,CAAC,UAAUR,IAAI,CAACnE,IAAI,CAACL,KAAK,UAAU,CAAC;MACjD;IACF;IAEA,OAAO;MACLmF,WAAW,EAAET,SAAS;MACtBhE,IAAI,EAAE,aAAa,IAAI+D,KAAK;MAC5B9C,OAAO,EAAEoD,KAAK,CAAC1D,IAAI,CAAC,MAAM;IAC5B,CAAC;EACH,CAAC;EAED+D,oBAAoBA,CAAC1B,KAAK,EAAE;IAC1B,MAAM;MAAE3E,KAAK,GAAG;IAAK,CAAC,GAAG2E,KAAK;IAC9B,IAAI,CAAC3E,KAAK,EAAE;MACV,OAAO,cAAc;IACvB;IACA,OAAO,EAAE;EACX,CAAC;EAEDsG,gBAAgBA,CAAC3B,KAAK,EAAE;IACtB,IAAI,CAACA,KAAK,CAAC9E,OAAO,EAAE;MAClB,OAAO,IAAI;IACb;IACA,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC8E,KAAK,CAAC9E,OAAO,CAAC,EAAE,IAAI,CAAC;EAC/C,CAAC;EAED0G,4BAA4BA,CAACC,gBAAgB,EAAE;IAC7C,MAAMC,YAAY,GAAGD,gBAAgB,CAACA,gBAAgB,CAACE,MAAM,GAAG,CAAC,CAAC;IAClE,MAAMC,YAAY,GAAGF,YAAY,EAAEhB,IAAI,IACnC;MAAEG,eAAe,CAAC,EAAE,MAAM;MAAEC,QAAQ,CAAC,EAAE,MAAM;IAAC,CAAC,GAC/C,SAAS;IAEb,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ;AACnC,UAAU,CAACc,YAAY,EAAEf,eAAe,IAC5B,CAAC,IAAI,CAAC,YAAY,CAACe,YAAY,CAACf,eAAe,CAAC,EAAE,IAAI,CACvD;AACX,UAAU,CAAC,IAAI;AACf,0DAA0D,CAAC,GAAG;AAC9D,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,qCAAqC,EAAE,IAAI;AACtE,UAAU,EAAE,IAAI;AAChB,QAAQ,EAAE,GAAG,CAAC;EAEV,CAAC;EAEDgB,uBAAuBA,CAAChE,OAAO,EAAEiE,CAAC,EAAE;IAAEC,OAAO;IAAEC;EAAM,CAAC,EAAE;IACtD,OACE,CAAC,uBAAuB,CACtB,OAAO,CAAC,CAACnE,OAAO,CAAC,CACjB,OAAO,CAAC,CAACkE,OAAO,CAAC,CACjB,KAAK,CAAC,CAACC,KAAK,CAAC,GACb;EAEN,CAAC;EAEDC,4BAA4BA,CAAA,EAAG;IAC7B,OAAO,CAAC,8BAA8B,GAAG;EAC3C,CAAC;EAEDC,yBAAyBA,CAAC9F,MAAM,EAAE;IAAE2F;EAAQ,CAAC,EAAE;IAC7C,OAAO,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC3F,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC2F,OAAO,CAAC,GAAG;EAC1E;AACF,CAAC,WAAWvI,OAAO,CAACgC,WAAW,EAAEa,oBAAoB,CAAC,CAAC;AAEzD,SAAA8F,wBAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAiC;IAAAzE,OAAA;IAAAkE,OAAA,EAAAQ,EAAA;IAAAP;EAAA,IAAAI,EAQhC;EANC,MAAAL,OAAA,GAAAQ,EAAe,KAAfzE,SAAe,GAAf,KAAe,GAAfyE,EAAe;EAOf,MAAAC,cAAA,GAAuBpJ,kBAAkB,CACvC,sBAAsB,EACtB,QAAQ,EACR,QACF,CAAC;EAAA,IAAAqJ,EAAA;EAAA,IAAAJ,CAAA,QAAAxE,OAAA;IAEC4E,EAAA,UAAO5E,OAAO,KAAK,QAAuC,GAA5B3D,SAAS,CAAC2D,OAAiB,CAAC,GAA1DA,OAA0D;IAAAwE,CAAA,MAAAxE,OAAA;IAAAwE,CAAA,MAAAI,EAAA;EAAA;IAAAA,EAAA,GAAAJ,CAAA;EAAA;EAD5D,MAAAjG,MAAA,GACEqG,EAA0D;EAE5D,IAAI,CAACrG,MAAM,CAAAG,IAAK;IAAA,IAAAmG,EAAA;IAAA,IAAAL,CAAA,QAAAM,MAAA,CAAAC,GAAA;MAEZF,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,wBAAwB,EAAtC,IAAI,CACP,EAFC,eAAe,CAEE;MAAAL,CAAA,MAAAK,EAAA;IAAA;MAAAA,EAAA,GAAAL,CAAA;IAAA;IAAA,OAFlBK,EAEkB;EAAA;EAItB;IAAAnG;EAAA,IAAiBH,MAAM;EAGvB,IAAIG,IAAI,CAAAV,SAAU,KAAK,YAAY;IAAA,IAAA6G,EAAA;IAAA,IAAAL,CAAA,QAAA9F,IAAA,CAAAL,KAAA,IAAAmG,CAAA,QAAA9F,IAAA,CAAAP,MAAA;MACjB0G,EAAA;QAAAzF,MAAA,EACNV,IAAI,CAAAP,MAAO;QAAAmB,MAAA,EACX,EAAE;QAAA0F,OAAA,EACD,KAAK;QAAAC,yBAAA,EACa,IAAI;QAAAC,wBAAA,EACLxG,IAAI,CAAAL;MAChC,CAAC;MAAAmG,CAAA,MAAA9F,IAAA,CAAAL,KAAA;MAAAmG,CAAA,MAAA9F,IAAA,CAAAP,MAAA;MAAAqG,CAAA,MAAAK,EAAA;IAAA;MAAAA,EAAA,GAAAL,CAAA;IAAA;IAND,MAAAW,OAAA,GAAgBN,EAMf;IAAA,IAAAO,EAAA;IAAA,IAAAZ,CAAA,QAAAW,OAAA,IAAAX,CAAA,QAAAN,OAAA;MACMkB,EAAA,IAAC,qBAAqB,CAAUD,OAAO,CAAPA,QAAM,CAAC,CAAWjB,OAAO,CAAPA,QAAM,CAAC,GAAI;MAAAM,CAAA,MAAAW,OAAA;MAAAX,CAAA,MAAAN,OAAA;MAAAM,CAAA,MAAAY,EAAA;IAAA;MAAAA,EAAA,GAAAZ,CAAA;IAAA;IAAA,OAA7DY,EAA6D;EAAA;EAItE,IAAI1G,IAAI,CAAAV,SAAU,KAAK,aAAa;IAClC,MAAAqH,SAAA,GAAkB3G,IAAI,CAAAH,MAAsD,GAA5CjC,iBAAiB,CAACoC,IAAI,CAAAH,MAAO,EAAE,IAAI,CAAC,GAAG,CAAK,GAA1D,CAA0D;IAE5E,IAAIA,MAAM,CAAAE,gBAAiB,KAAK,SAAS;MACvC,IAAIyF,OAAO;QAAA,IAAAW,EAAA;QAAA,IAAAL,CAAA,QAAAa,SAAA,IAAAb,CAAA,SAAA9F,IAAA,CAAAR,WAAA;UAGL2G,EAAA,IAAC,IAAI,CACF,CAAAnG,IAAI,CAAAR,WAAW,CAAE,EAAGmH,UAAQ,CAAE,OACjC,EAFC,IAAI,CAEE;UAAAb,CAAA,MAAAa,SAAA;UAAAb,CAAA,OAAA9F,IAAA,CAAAR,WAAA;UAAAsG,CAAA,OAAAK,EAAA;QAAA;UAAAA,EAAA,GAAAL,CAAA;QAAA;QAAA,IAAAY,EAAA;QAAA,IAAAZ,CAAA,SAAA9F,IAAA,CAAAJ,MAAA,IAAAkG,CAAA,SAAAL,KAAA;UAEJiB,EAAA,GAAA1G,IAAI,CAAAJ,MAEJ,IADC,CAAC,kBAAkB,CAAS,MAAW,CAAX,CAAAI,IAAI,CAAAJ,MAAM,CAAC,CAAS6F,KAAK,CAALA,MAAI,CAAC,CAAE,GAAG,CAAH,KAAE,CAAC,GAC3D;UAAAK,CAAA,OAAA9F,IAAA,CAAAJ,MAAA;UAAAkG,CAAA,OAAAL,KAAA;UAAAK,CAAA,OAAAY,EAAA;QAAA;UAAAA,EAAA,GAAAZ,CAAA;QAAA;QAAA,IAAAc,EAAA;QAAA,IAAAd,CAAA,SAAA9F,IAAA,CAAAH,MAAA,IAAAiG,CAAA,SAAAL,KAAA;UACAmB,EAAA,GAAA5G,IAAI,CAAAH,MAOJ,IANC,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,oBAAoB,CACV,OAAqC,CAArC,EAAC;cAAAQ,IAAA,EAAQ,MAAM;cAAAwG,IAAA,EAAQ7G,IAAI,CAAAH;YAAQ,CAAC,EAAC,CACvC4F,KAAK,CAALA,MAAI,CAAC,GAEhB,EALC,GAAG,CAML;UAAAK,CAAA,OAAA9F,IAAA,CAAAH,MAAA;UAAAiG,CAAA,OAAAL,KAAA;UAAAK,CAAA,OAAAc,EAAA;QAAA;UAAAA,EAAA,GAAAd,CAAA;QAAA;QAAA,IAAAgB,EAAA;QAAA,IAAAhB,CAAA,SAAA9F,IAAA,CAAAL,KAAA;UACAmH,EAAA,GAAA9G,IAAI,CAAAL,KASJ,IARC,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAY,SAAC,CAAD,GAAC,CACtC,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAC,IAAI,CAAJ,KAAG,CAAC,CAAC,MAEzB,EAFC,IAAI,CAGL,CAAC,GAAG,CAAc,WAAC,CAAD,GAAC,CACjB,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAE,CAAAK,IAAI,CAAAL,KAAK,CAAE,EAA/B,IAAI,CACP,EAFC,GAAG,CAGN,EAPC,GAAG,CAQL;UAAAmG,CAAA,OAAA9F,IAAA,CAAAL,KAAA;UAAAmG,CAAA,OAAAgB,EAAA;QAAA;UAAAA,EAAA,GAAAhB,CAAA;QAAA;QAAA,IAAAiB,EAAA;QAAA,IAAAjB,CAAA,SAAAY,EAAA,IAAAZ,CAAA,SAAAc,EAAA,IAAAd,CAAA,SAAAgB,EAAA;UArBHC,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAc,WAAC,CAAD,GAAC,CAAa,SAAC,CAAD,GAAC,CACrD,CAAAL,EAED,CACC,CAAAE,EAOD,CACC,CAAAE,EASD,CACF,EAtBC,GAAG,CAsBE;UAAAhB,CAAA,OAAAY,EAAA;UAAAZ,CAAA,OAAAc,EAAA;UAAAd,CAAA,OAAAgB,EAAA;UAAAhB,CAAA,OAAAiB,EAAA;QAAA;UAAAA,EAAA,GAAAjB,CAAA;QAAA;QAAA,IAAAkB,EAAA;QAAA,IAAAlB,CAAA,SAAAK,EAAA,IAAAL,CAAA,SAAAiB,EAAA;UA1BRC,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAb,EAEM,CACN,CAAAY,EAsBK,CACP,EA3BC,GAAG,CA2BE;UAAAjB,CAAA,OAAAK,EAAA;UAAAL,CAAA,OAAAiB,EAAA;UAAAjB,CAAA,OAAAkB,EAAA;QAAA;UAAAA,EAAA,GAAAlB,CAAA;QAAA;QAAA,OA3BNkB,EA2BM;MAAA;MAET,IAAAb,EAAA;MAAA,IAAAL,CAAA,SAAAG,cAAA;QAECE,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,aAAcF,eAAa,CAAE,WAAW,EAAtD,IAAI,CACP,EAFC,eAAe,CAEE;QAAAH,CAAA,OAAAG,cAAA;QAAAH,CAAA,OAAAK,EAAA;MAAA;QAAAA,EAAA,GAAAL,CAAA;MAAA;MAAA,OAFlBK,EAEkB;IAAA;IAItB,IAAItG,MAAM,CAAAE,gBAAiB,KAAK,SAAsC,IAAzBC,IAAI,CAAAT,MAAO,KAAK,SAAS;MAAA,IAAA4G,EAAA;MAAA,IAAAL,CAAA,SAAAM,MAAA,CAAAC,GAAA;QAElEF,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,sBAAsB,EAApC,IAAI,CACP,EAFC,eAAe,CAEE;QAAAL,CAAA,OAAAK,EAAA;MAAA;QAAAA,EAAA,GAAAL,CAAA;MAAA;MAAA,OAFlBK,EAEkB;IAAA;IAItB,IAAItG,MAAM,CAAAE,gBAAiB,KAAK,WAAW;MAAA,IAAAoG,EAAA;MAAA,IAAAL,CAAA,SAAAM,MAAA,CAAAC,GAAA;QAEvCF,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,sBAAsB,EAApC,IAAI,CACP,EAFC,eAAe,CAEE;QAAAL,CAAA,OAAAK,EAAA;MAAA;QAAAA,EAAA,GAAAL,CAAA;MAAA;MAAA,OAFlBK,EAEkB;IAAA;IAErB,IAAAA,EAAA;IAAA,IAAAL,CAAA,SAAAM,MAAA,CAAAC,GAAA;MAGCF,EAAA,IAAC,eAAe,CACd,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,cAAc,EAA5B,IAAI,CACP,EAFC,eAAe,CAEE;MAAAL,CAAA,OAAAK,EAAA;IAAA;MAAAA,EAAA,GAAAL,CAAA;IAAA;IAAA,OAFlBK,EAEkB;EAAA;EAKtB,IAAInG,IAAI,CAAAV,SAAU,KAAK,cAAc;IAAA,IAAA6G,EAAA;IAAA,IAAAL,CAAA,SAAA9F,IAAA,CAAAR,WAAA,IAAAsG,CAAA,SAAA9F,IAAA,CAAAT,MAAA;MAG/B4G,EAAA,IAAC,IAAI,CAAC,EACS,CAAAnG,IAAI,CAAAR,WAAW,CAAE,EAAG,CAAAQ,IAAI,CAAAT,MAAM,CAAE,CAC/C,EAFC,IAAI,CAEE;MAAAuG,CAAA,OAAA9F,IAAA,CAAAR,WAAA;MAAAsG,CAAA,OAAA9F,IAAA,CAAAT,MAAA;MAAAuG,CAAA,OAAAK,EAAA;IAAA;MAAAA,EAAA,GAAAL,CAAA;IAAA;IAAA,IAAAY,EAAA;IAAA,IAAAZ,CAAA,SAAA9F,IAAA,CAAAP,MAAA,IAAAqG,CAAA,SAAAN,OAAA;MACNkB,EAAA,GAAA1G,IAAI,CAAAP,MAAkB,IAAtB+F,OAIA,IAHC,CAAC,GAAG,CAAc,WAAC,CAAD,GAAC,CAAa,SAAC,CAAD,GAAC,CAC/B,CAAC,IAAI,CAAE,CAAAxF,IAAI,CAAAP,MAAM,CAAE,EAAlB,IAAI,CACP,EAFC,GAAG,CAGL;MAAAqG,CAAA,OAAA9F,IAAA,CAAAP,MAAA;MAAAqG,CAAA,OAAAN,OAAA;MAAAM,CAAA,OAAAY,EAAA;IAAA;MAAAA,EAAA,GAAAZ,CAAA;IAAA;IAAA,IAAAc,EAAA;IAAA,IAAAd,CAAA,SAAAG,cAAA,IAAAH,CAAA,SAAA9F,IAAA,CAAAP,MAAA,IAAAqG,CAAA,SAAAN,OAAA;MACAoB,EAAA,IAACpB,OAAsB,IAAXxF,IAAI,CAAAP,MAIhB,IAHC,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CACX,QAAM,CAAE,CAAEwG,eAAa,CAAE,WAC5B,EAFC,IAAI,CAGN;MAAAH,CAAA,OAAAG,cAAA;MAAAH,CAAA,OAAA9F,IAAA,CAAAP,MAAA;MAAAqG,CAAA,OAAAN,OAAA;MAAAM,CAAA,OAAAc,EAAA;IAAA;MAAAA,EAAA,GAAAd,CAAA;IAAA;IAAA,IAAAgB,EAAA;IAAA,IAAAhB,CAAA,SAAAK,EAAA,IAAAL,CAAA,SAAAY,EAAA,IAAAZ,CAAA,SAAAc,EAAA;MAbHE,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAX,EAEM,CACL,CAAAO,EAID,CACC,CAAAE,EAID,CACF,EAdC,GAAG,CAcE;MAAAd,CAAA,OAAAK,EAAA;MAAAL,CAAA,OAAAY,EAAA;MAAAZ,CAAA,OAAAc,EAAA;MAAAd,CAAA,OAAAgB,EAAA;IAAA;MAAAA,EAAA,GAAAhB,CAAA;IAAA;IAAA,OAdNgB,EAcM;EAAA;EAET,IAAAX,EAAA;EAAA,IAAAL,CAAA,SAAA9F,IAAA,CAAAR,WAAA,IAAAsG,CAAA,SAAA9F,IAAA,CAAAT,MAAA;IAKG4G,EAAA,IAAC,IAAI,CAAC,EACS,CAAAnG,IAAI,CAAAR,WAAW,CAAE,EAAG,CAAAQ,IAAI,CAAAT,MAAM,CAAE,CAC/C,EAFC,IAAI,CAEE;IAAAuG,CAAA,OAAA9F,IAAA,CAAAR,WAAA;IAAAsG,CAAA,OAAA9F,IAAA,CAAAT,MAAA;IAAAuG,CAAA,OAAAK,EAAA;EAAA;IAAAA,EAAA,GAAAL,CAAA;EAAA;EAAA,IAAAY,EAAA;EAAA,IAAAZ,CAAA,SAAA9F,IAAA,CAAAP,MAAA;IACNiH,EAAA,GAAA1G,IAAI,CAAAP,MAIJ,IAHC,CAAC,GAAG,CAAc,WAAC,CAAD,GAAC,CACjB,CAAC,IAAI,CAAE,CAAAO,IAAI,CAAAP,MAAO,CAAAwH,KAAM,CAAC,CAAC,EAAE,GAAG,EAAE,EAAhC,IAAI,CACP,EAFC,GAAG,CAGL;IAAAnB,CAAA,OAAA9F,IAAA,CAAAP,MAAA;IAAAqG,CAAA,OAAAY,EAAA;EAAA;IAAAA,EAAA,GAAAZ,CAAA;EAAA;EAAA,IAAAc,EAAA;EAAA,IAAAd,CAAA,SAAAK,EAAA,IAAAL,CAAA,SAAAY,EAAA;IARHE,EAAA,IAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAAT,EAEM,CACL,CAAAO,EAID,CACF,EATC,GAAG,CASE;IAAAZ,CAAA,OAAAK,EAAA;IAAAL,CAAA,OAAAY,EAAA;IAAAZ,CAAA,OAAAc,EAAA;EAAA;IAAAA,EAAA,GAAAd,CAAA;EAAA;EAAA,OATNc,EASM;AAAA;AAIV,eAAenE,cAAc","ignoreList":[]}