@projectcor/maia-components 2.50.0 → 2.50.1-1

package/lib/hooks/useChatManager/useChatManager.spec.js

@@ -0,0 +1,2409 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { GlobalContextTestProvider, testAgent } from '../../test/global-context';
+import { useSessionsStore } from '../../store/sessions/useSessionsStore';
+import { sessionStreamManager } from '../../store/sessions/sessionStreamManager';
+import { ChatHistoryRole } from '../../types/Chat';
+import { Feedback } from '../../components/molecules/MessageFeedback/MessageFeedback';
+import maia from '../../services/maia';
+import { activeView } from '../../store/sessions/activeView';
+import { useOrchestratorStream } from '../useOrchestratorStream';
+import { getChatsStoreState } from '../../store/useChatsStore';
+import { notifySessionFinishedInBackground } from '../../store/sessions/sessionNotifications';
+import { fetchAgentDetail } from '../../services/maia/Agents/fetchAgentDetail';
+import { MAIA_HOURS_CHARGED_EVENT } from '../../constants/plannerSyncEvents';
+import { streamingPlaceholderMessageId } from '../../utils/streamActivityMessages';
+import { useChatManager } from './useChatManager';
+import { jsx as _jsx } from "react/jsx-runtime";
+var fetchAgentDetailMock = fetchAgentDetail;
+var mockUseOrchestratorStream = useOrchestratorStream;
+var streamCallbacks = {};
+var startContinueStreamMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var askMaiaMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var retryCompletionMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var stopStreamingMock = jest.fn();
+var replaceMessagesMock = jest.fn();
+var addMessageMock = jest.fn();
+var eventMock = jest.fn();
+var chatMessagesState = {
+  loadingMessages: false,
+  messages: [],
+  isLoadingMoreMessages: false,
+  loadMessages: jest.fn(),
+  addMessage: addMessageMock,
+  removeMessage: jest.fn(),
+  replaceMessages: replaceMessagesMock,
+  handleScroll: jest.fn()
+};
+jest.mock('../useChatMessages', function () {
+  return {
+    useChatMessages: function useChatMessages() {
+      return chatMessagesState;
+    }
+  };
+});
+jest.mock('../useOrchestratorStream', function () {
+  return {
+    useOrchestratorStream: jest.fn()
+  };
+});
+jest.mock('../useProjects', function () {
+  return {
+    useProjects: function useProjects() {
+      return {
+        fetchProjects: jest.fn().mockResolvedValue([])
+      };
+    }
+  };
+});
+jest.mock('../useTabTaskDefault', function () {
+  return {
+    useTabTaskDefault: function useTabTaskDefault() {
+      return {
+        getTabTaskDefault: jest.fn().mockResolvedValue('detail')
+      };
+    }
+  };
+});
+jest.mock('../useEvent', function () {
+  return {
+    EVENTS: {
+      pmAiTypedText: 'PM_AI_TYPED_TEXT'
+    },
+    useEvent: function useEvent() {
+      return eventMock;
+    }
+  };
+});
+jest.mock('../../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        id: 7,
+        firstName: 'Ana',
+        lastName: 'García',
+        picture: 'pic.png',
+        lang: 'es',
+        company_id: 10
+      };
+    }
+  };
+});
+jest.mock('../../store/useChatsStore', function () {
+  var state = {
+    setActiveChatId: jest.fn(),
+    markChatAsRead: jest.fn(),
+    markChatAsUnread: jest.fn(),
+    isChatViewVisible: true,
+    chats: [],
+    prependChat: jest.fn()
+  };
+  var useChatsStore = function useChatsStore(selector) {
+    return selector(state);
+  };
+  Object.assign(useChatsStore, {
+    getState: function getState() {
+      return state;
+    }
+  });
+  return {
+    useChatsStore: useChatsStore,
+    getChatsStoreState: function getChatsStoreState() {
+      return state;
+    }
+  };
+});
+jest.mock('../../services/maia', function () {
+  return {
+    __esModule: true,
+    "default": {
+      Chats: {
+        wasHelpfulChat: jest.fn()
+      }
+    }
+  };
+});
+jest.mock('../../services/maia/Agents/fetchAgentDetail', function () {
+  return {
+    fetchAgentDetail: jest.fn()
+  };
+});
+jest.mock('../../store/sessions/sessionNotifications', function () {
+  return {
+    notifySessionFinishedInBackground: jest.fn(),
+    ensureSessionNotificationsInitialized: jest.fn()
+  };
+});
+jest.mock('../../store/sessions/sessionStreamManager', function () {
+  return {
+    sessionStreamManager: {
+      isActive: jest.fn(function () {
+        return false;
+      }),
+      getActiveCount: jest.fn(function () {
+        return 0;
+      }),
+      startStream: jest.fn(),
+      startContinueStream: function startContinueStream() {
+        return startContinueStreamMock.apply(void 0, arguments);
+      },
+      stopStream: jest.fn()
+    },
+    MAX_CONCURRENT_STREAMS: 3
+  };
+});
+var wrapper = function wrapper(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+    value: {
+      agent: testAgent
+    },
+    children: children
+  });
+};
+describe('useChatManager', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    streamCallbacks = {};
+    mockUseOrchestratorStream.mockImplementation(function (options) {
+      streamCallbacks = {
+        onError: options.onError,
+        onStreamUpdate: options.onStreamUpdate,
+        onStop: options.onStop,
+        onApprovalRequired: options.onApprovalRequired,
+        onFinishStream: options.onFinishStream
+      };
+      return {
+        askMaia: askMaiaMock,
+        retryCompletion: retryCompletionMock,
+        isLoading: false,
+        isWriting: false,
+        loadingMessage: '',
+        streamActivity: null,
+        updateStreamActivity: jest.fn(),
+        stopStreaming: stopStreamingMock
+      };
+    });
+    chatMessagesState.loadingMessages = false;
+    chatMessagesState.messages = [];
+    useSessionsStore.setState({
+      meta: {},
+      messages: {},
+      viewCache: {}
+    });
+    activeView.set(null);
+    sessionStreamManager.isActive.mockReturnValue(false);
+    sessionStreamManager.getActiveCount.mockReturnValue(0);
+    startContinueStreamMock.mockResolvedValue({
+      started: true
+    });
+    askMaiaMock.mockResolvedValue({
+      started: true
+    });
+    retryCompletionMock.mockResolvedValue({
+      started: true
+    });
+  });
+  it('starts with empty messages and send enabled', function () {
+    var _renderHook = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook.result;
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.isDisabled).toBe(false);
+  });
+  it('sendMessage delegates to askMaia with the current session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook2.result;
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.sendMessage('Hola MAIA');
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola MAIA',
+            chatId: 'session-1',
+            agentId: testAgent.id,
+            agentName: testAgent.name
+          }));
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola MAIA',
+            role: 'user'
+          }));
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('does not send when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var dispatchSpy, _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          ;
+          sessionStreamManager.getActiveCount.mockReturnValue(3);
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook3 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook3.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.sendMessage('Hola');
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('stopGeneration stops the active stream', function () {
+    var _renderHook4 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook4.result;
+    act(function () {
+      result.current.stopGeneration();
+    });
+    expect(stopStreamingMock).toHaveBeenCalled();
+  });
+  it('resetChat clears the active chat id in the store hook path', function () {
+    var _renderHook5 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook5.result;
+    act(function () {
+      result.current.resetChat();
+    });
+    expect(result.current.currentChatId).not.toBe('session-1');
+  });
+  it('does not send while messages are loading', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _renderHook6, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          chatMessagesState.loadingMessages = true;
+          _renderHook6 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook6.result;
+          expect(result.current.isDisabled).toBe(true);
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.sendMessage('Hola');
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('includes context mentions when they are sent via options', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var _renderHook7, result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _renderHook7 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook7.result;
+          _context8.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+            return _regeneratorRuntime.wrap(function (_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 1;
+                  return result.current.sendMessage('Hola', {
+                    mentions: [{
+                      id: 'u1',
+                      type: 'user',
+                      label: 'Ana'
+                    }]
+                  });
+                case 1:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            contextMessage: expect.objectContaining({
+              user: expect.arrayContaining([expect.objectContaining({
+                id: 'u1',
+                name: 'Ana'
+              })])
+            })
+          }));
+          expect(eventMock).toHaveBeenCalledWith('PM_AI_TYPED_TEXT');
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('retries a cancelled assistant turn through askMaia', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+    var _renderHook8, result;
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-1',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-stream-1-cancelled',
+            message: 'Respuesta parcial',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date(),
+            isFrontendCancelled: true
+          }];
+          _renderHook8 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook8.result;
+          _context0.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+            return _regeneratorRuntime.wrap(function (_context9) {
+              while (1) switch (_context9.prev = _context9.next) {
+                case 0:
+                  _context9.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context9.stop();
+              }
+            }, _callee9);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola',
+            chatId: 'session-1'
+          }));
+          expect(replaceMessagesMock).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  })));
+  it('re-asks with the new project when a pending question exists', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var setProject, project, _renderHook9, result;
+    return _regeneratorRuntime.wrap(function (_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          setProject = jest.fn();
+          project = {
+            id: 10,
+            name: 'Proyecto A'
+          };
+          _renderHook9 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref11) {
+              var children = _ref11.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: project,
+                  setProject: setProject
+                },
+                children: children
+              });
+            }
+          }), result = _renderHook9.result;
+          _context10.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+            return _regeneratorRuntime.wrap(function (_context1) {
+              while (1) switch (_context1.prev = _context1.next) {
+                case 0:
+                  _context1.next = 1;
+                  return result.current.sendMessage('¿Cuántas horas van?');
+                case 1:
+                case "end":
+                  return _context1.stop();
+              }
+            }, _callee1);
+          })));
+        case 1:
+          askMaiaMock.mockClear();
+          act(function () {
+            result.current.changeProject({
+              id: 99,
+              name: 'Proyecto X',
+              feeId: 5,
+              clientId: 7
+            });
+          });
+          expect(setProject).toHaveBeenCalledWith(expect.objectContaining({
+            id: 99
+          }));
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: '¿Cuántas horas van?',
+            projectId: 99,
+            feeId: 5,
+            clientId: 7
+          }));
+        case 2:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it('does not change project when there is no pending user question', function () {
+    var _renderHook0 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook0.result;
+    act(function () {
+      result.current.changeProject({
+        id: 99,
+        name: 'Proyecto X'
+      });
+    });
+    expect(askMaiaMock).not.toHaveBeenCalled();
+  });
+  it('starts a continue stream when rejecting a HITL action', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+    var _renderHook1, result;
+    return _regeneratorRuntime.wrap(function (_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          _renderHook1 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook1.result;
+          _context12.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+            return _regeneratorRuntime.wrap(function (_context11) {
+              while (1) switch (_context11.prev = _context11.next) {
+                case 0:
+                  _context11.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'reject');
+                case 1:
+                case "end":
+                  return _context11.stop();
+              }
+            }, _callee11);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'reject'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it('starts a continue stream when approving a HITL action', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+    var _renderHook10, result;
+    return _regeneratorRuntime.wrap(function (_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          _renderHook10 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook10.result;
+          _context14.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+            return _regeneratorRuntime.wrap(function (_context13) {
+              while (1) switch (_context13.prev = _context13.next) {
+                case 0:
+                  _context13.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'approve');
+                case 1:
+                case "end":
+                  return _context13.stop();
+              }
+            }, _callee13);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            continueRequest: expect.objectContaining({
+              threadIds: ['thread-a'],
+              decision: 'approve'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it('submits feedback through the maia chats service', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+    var _renderHook11, result;
+    return _regeneratorRuntime.wrap(function (_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'answer-1',
+            message: 'Respuesta',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date()
+          }];
+          jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(true);
+          _renderHook11 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook11.result;
+          _context16.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+            return _regeneratorRuntime.wrap(function (_context15) {
+              while (1) switch (_context15.prev = _context15.next) {
+                case 0:
+                  _context15.next = 1;
+                  return result.current.handleFeedback(Feedback.THUMBS_UP, 'answer-1');
+                case 1:
+                case "end":
+                  return _context15.stop();
+              }
+            }, _callee15);
+          })));
+        case 1:
+          expect(maia.Chats.wasHelpfulChat).toHaveBeenCalledWith('answer-1', true);
+        case 2:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+  it('ignores feedback updates when the API rejects the vote', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+    var _renderHook12, result;
+    return _regeneratorRuntime.wrap(function (_context18) {
+      while (1) switch (_context18.prev = _context18.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'answer-1',
+            message: 'Respuesta',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date()
+          }];
+          jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(false);
+          _renderHook12 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook12.result;
+          _context18.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+            return _regeneratorRuntime.wrap(function (_context17) {
+              while (1) switch (_context17.prev = _context17.next) {
+                case 0:
+                  _context17.next = 1;
+                  return result.current.handleFeedback(Feedback.THUMBS_DOWN, 'answer-1');
+                case 1:
+                case "end":
+                  return _context17.stop();
+              }
+            }, _callee17);
+          })));
+        case 1:
+          expect(chatMessagesState.messages[0]).not.toHaveProperty('wasHelpful');
+        case 2:
+        case "end":
+          return _context18.stop();
+      }
+    }, _callee18);
+  })));
+  it('does not start approval streams without thread ids', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+    var consoleSpy, _renderHook13, result;
+    return _regeneratorRuntime.wrap(function (_context20) {
+      while (1) switch (_context20.prev = _context20.next) {
+        case 0:
+          consoleSpy = jest.spyOn(console, 'error').mockImplementation(function () {
+            return undefined;
+          });
+          _renderHook13 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook13.result;
+          _context20.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+            return _regeneratorRuntime.wrap(function (_context19) {
+              while (1) switch (_context19.prev = _context19.next) {
+                case 0:
+                  _context19.next = 1;
+                  return result.current.handleApprovalDecision([], 'approve');
+                case 1:
+                case "end":
+                  return _context19.stop();
+              }
+            }, _callee19);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+          expect(consoleSpy).toHaveBeenCalled();
+          consoleSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context20.stop();
+      }
+    }, _callee20);
+  })));
+  it('sendMessage accepts a bare attachments array', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+    var attachment, _renderHook14, result;
+    return _regeneratorRuntime.wrap(function (_context22) {
+      while (1) switch (_context22.prev = _context22.next) {
+        case 0:
+          attachment = {
+            id: 'a1',
+            name: 'doc.pdf',
+            type: 'pdf',
+            size: 1,
+            file: new File([], 'doc.pdf')
+          };
+          _renderHook14 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook14.result;
+          _context22.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+            return _regeneratorRuntime.wrap(function (_context21) {
+              while (1) switch (_context21.prev = _context21.next) {
+                case 0:
+                  _context21.next = 1;
+                  return result.current.sendMessage('Con adjunto', [attachment]);
+                case 1:
+                case "end":
+                  return _context21.stop();
+              }
+            }, _callee21);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Con adjunto',
+            attachments: [attachment]
+          }));
+        case 2:
+        case "end":
+          return _context22.stop();
+      }
+    }, _callee22);
+  })));
+  it('loads messages when initializeChat runs with an existing chat id', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+    var _renderHook15, result;
+    return _regeneratorRuntime.wrap(function (_context24) {
+      while (1) switch (_context24.prev = _context24.next) {
+        case 0:
+          chatMessagesState.loadMessages.mockResolvedValue(undefined);
+          _renderHook15 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook15.result;
+          _context24.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+            return _regeneratorRuntime.wrap(function (_context23) {
+              while (1) switch (_context23.prev = _context23.next) {
+                case 0:
+                  _context23.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context23.stop();
+              }
+            }, _callee23);
+          })));
+        case 1:
+          expect(chatMessagesState.loadMessages).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context24.stop();
+      }
+    }, _callee24);
+  })));
+  it('auto-sends the initial FAQ when initializeChat receives faqId only', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+    var _renderHook16, result;
+    return _regeneratorRuntime.wrap(function (_context26) {
+      while (1) switch (_context26.prev = _context26.next) {
+        case 0:
+          _renderHook16 = renderHook(function () {
+            return useChatManager({
+              userInitialMessage: {
+                message: '',
+                attachments: [],
+                faqId: 'faq-rentabilidad'
+              },
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook16.result;
+          _context26.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+            return _regeneratorRuntime.wrap(function (_context25) {
+              while (1) switch (_context25.prev = _context25.next) {
+                case 0:
+                  _context25.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context25.stop();
+              }
+            }, _callee25);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            faqId: 'faq-rentabilidad'
+          }));
+        case 2:
+        case "end":
+          return _context26.stop();
+      }
+    }, _callee26);
+  })));
+  it('skips initializeChat auto-send when the initial payload is empty', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee28() {
+    var _renderHook17, result;
+    return _regeneratorRuntime.wrap(function (_context28) {
+      while (1) switch (_context28.prev = _context28.next) {
+        case 0:
+          _renderHook17 = renderHook(function () {
+            return useChatManager({
+              userInitialMessage: {
+                message: '   ',
+                attachments: []
+              },
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook17.result;
+          _context28.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee27() {
+            return _regeneratorRuntime.wrap(function (_context27) {
+              while (1) switch (_context27.prev = _context27.next) {
+                case 0:
+                  _context27.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context27.stop();
+              }
+            }, _callee27);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(chatMessagesState.loadMessages).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context28.stop();
+      }
+    }, _callee28);
+  })));
+  it('does not retry when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee30() {
+    var dispatchSpy, _renderHook18, result;
+    return _regeneratorRuntime.wrap(function (_context30) {
+      while (1) switch (_context30.prev = _context30.next) {
+        case 0:
+          ;
+          sessionStreamManager.getActiveCount.mockReturnValue(3);
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          chatMessagesState.messages = [{
+            id: 'question-1',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-stream-1-cancelled',
+            message: 'Respuesta parcial',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date(),
+            isFrontendCancelled: true
+          }];
+          _renderHook18 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook18.result;
+          _context30.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee29() {
+            return _regeneratorRuntime.wrap(function (_context29) {
+              while (1) switch (_context29.prev = _context29.next) {
+                case 0:
+                  _context29.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context29.stop();
+              }
+            }, _callee29);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context30.stop();
+      }
+    }, _callee30);
+  })));
+  it('does not start approval streams when the session is already streaming', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee32() {
+    var _renderHook19, result;
+    return _regeneratorRuntime.wrap(function (_context32) {
+      while (1) switch (_context32.prev = _context32.next) {
+        case 0:
+          activeView.set('session-1');
+          sessionStreamManager.isActive.mockReturnValue(true);
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {}
+              }]
+            }
+          }];
+          _renderHook19 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook19.result;
+          _context32.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee31() {
+            return _regeneratorRuntime.wrap(function (_context31) {
+              while (1) switch (_context31.prev = _context31.next) {
+                case 0:
+                  _context31.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'approve');
+                case 1:
+                case "end":
+                  return _context31.stop();
+              }
+            }, _callee31);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context32.stop();
+      }
+    }, _callee32);
+  })));
+  it('starts a continue stream with edit decision when actions were edited', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee34() {
+    var editedActions, _renderHook20, result;
+    return _regeneratorRuntime.wrap(function (_context34) {
+      while (1) switch (_context34.prev = _context34.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          editedActions = [{
+            tool_name: 'edit_task',
+            args: {
+              task_id: 99
+            }
+          }];
+          _renderHook20 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook20.result;
+          _context34.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee33() {
+            return _regeneratorRuntime.wrap(function (_context33) {
+              while (1) switch (_context33.prev = _context33.next) {
+                case 0:
+                  _context33.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'reject', editedActions);
+                case 1:
+                case "end":
+                  return _context33.stop();
+              }
+            }, _callee33);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'edit',
+              editedActions: editedActions
+            })
+          }));
+        case 2:
+        case "end":
+          return _context34.stop();
+      }
+    }, _callee34);
+  })));
+  it('commits access denied stream errors without retry suggestions', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr, _streamCallbacks;
+      (_streamCallbacks$onEr = (_streamCallbacks = streamCallbacks).onError) === null || _streamCallbacks$onEr === void 0 || _streamCallbacks$onEr.call(_streamCallbacks, {
+        sessionId: 'session-1',
+        messageId: 'msg-err',
+        placeholderId: 'answer-msg-err-streaming'
+      }, "Access denied: You don't have permission to access this agent");
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: 'chat.errorAccessDenied'
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('maps prompt-too-long stream errors without retry suggestions', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr2, _streamCallbacks2;
+      (_streamCallbacks$onEr2 = (_streamCallbacks2 = streamCallbacks).onError) === null || _streamCallbacks$onEr2 === void 0 || _streamCallbacks$onEr2.call(_streamCallbacks2, {
+        sessionId: 'session-1',
+        messageId: 'msg-long',
+        placeholderId: 'answer-msg-long-streaming'
+      }, 'invalid_request_error', 'prompt is too long: 12000 tokens');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: 'chat.errorPromptTooLong'
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('marks background sessions unread when a stream errors off-screen', function () {
+    activeView.set('session-visible');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-visible',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr3, _streamCallbacks3;
+      (_streamCallbacks$onEr3 = (_streamCallbacks3 = streamCallbacks).onError) === null || _streamCallbacks$onEr3 === void 0 || _streamCallbacks$onEr3.call(_streamCallbacks3, {
+        sessionId: 'session-bg',
+        messageId: 'bg-err',
+        placeholderId: 'answer-bg-err-streaming'
+      }, 'server_error');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'error');
+  });
+  it('adds retry suggestions for generic stream errors on the active session', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr4, _streamCallbacks4;
+      (_streamCallbacks$onEr4 = (_streamCallbacks4 = streamCallbacks).onError) === null || _streamCallbacks$onEr4 === void 0 || _streamCallbacks$onEr4.call(_streamCallbacks4, {
+        sessionId: 'session-1',
+        messageId: 'msg-500',
+        placeholderId: 'answer-msg-500-streaming'
+      }, 'server_error');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('creates the streaming placeholder on the first stream update', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    var ctx = {
+      sessionId: 'session-1',
+      messageId: 'live-1',
+      placeholderId: 'answer-live-1-streaming'
+    };
+    act(function () {
+      var _streamCallbacks$onSt, _streamCallbacks5;
+      (_streamCallbacks$onSt = (_streamCallbacks5 = streamCallbacks).onStreamUpdate) === null || _streamCallbacks$onSt === void 0 || _streamCallbacks$onSt.call(_streamCallbacks5, ctx, 'Generando');
+    });
+    expect(useSessionsStore.getState().getMessages('session-1')).toEqual(expect.arrayContaining([expect.objectContaining({
+      id: 'answer-live-1-streaming',
+      message: ''
+    })]));
+  });
+  it('marks background sessions unread when a stream finishes off-screen', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee36() {
+    return _regeneratorRuntime.wrap(function (_context36) {
+      while (1) switch (_context36.prev = _context36.next) {
+        case 0:
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          activeView.set('session-visible');
+          _context36.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee35() {
+            var _streamCallbacks$onFi, _streamCallbacks6;
+            return _regeneratorRuntime.wrap(function (_context35) {
+              while (1) switch (_context35.prev = _context35.next) {
+                case 0:
+                  _context35.next = 1;
+                  return (_streamCallbacks$onFi = (_streamCallbacks6 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi === void 0 ? void 0 : _streamCallbacks$onFi.call(_streamCallbacks6, {
+                    sessionId: 'session-1',
+                    messageId: 'bg-1',
+                    placeholderId: 'answer-bg-1-streaming'
+                  }, 'Respuesta en background', [], 'memory-bg-1', null, null, null);
+                case 1:
+                case "end":
+                  return _context35.stop();
+              }
+            }, _callee35);
+          })));
+        case 1:
+          expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1');
+          expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'complete');
+          expect(addMessageMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context36.stop();
+      }
+    }, _callee36);
+  })));
+  it('commits prompt-too-long stream errors without retry suggestions', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr5, _streamCallbacks7;
+      (_streamCallbacks$onEr5 = (_streamCallbacks7 = streamCallbacks).onError) === null || _streamCallbacks$onEr5 === void 0 || _streamCallbacks$onEr5.call(_streamCallbacks7, {
+        sessionId: 'session-1',
+        messageId: 'msg-long',
+        placeholderId: 'answer-msg-long-streaming'
+      }, 'invalid_request_error', 'prompt is too long: 12000 tokens');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: expect.stringContaining('chat.errorPromptTooLong')
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('marks background sessions unread when a stream errors off-screen', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    activeView.set('other-session');
+    act(function () {
+      var _streamCallbacks$onEr6, _streamCallbacks8;
+      (_streamCallbacks$onEr6 = (_streamCallbacks8 = streamCallbacks).onError) === null || _streamCallbacks$onEr6 === void 0 || _streamCallbacks$onEr6.call(_streamCallbacks8, {
+        sessionId: 'session-1',
+        messageId: 'bg-err',
+        placeholderId: 'answer-bg-err-streaming'
+      }, 'server_error');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'error');
+  });
+  it('syncs task creation with the project dashboard when approval completes on the active session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee38() {
+    var addExistingTaskToDashboard, originalPathname, taskUrl;
+    return _regeneratorRuntime.wrap(function (_context38) {
+      while (1) switch (_context38.prev = _context38.next) {
+        case 0:
+          addExistingTaskToDashboard = jest.fn();
+          window.newProjectDashboard = {
+            addExistingTaskToDashboard: addExistingTaskToDashboard
+          };
+          originalPathname = window.location.pathname;
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: '/projects/42/tasks'
+            })
+          });
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'user-1',
+            message: 'Crea la tarea',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date(),
+            projectId: 42
+          }, {
+            id: 'approval-msg',
+            message: '¿Confirmás?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 't1',
+                tool_name: 'create_task',
+                tool_args: {
+                  task_id: 55
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref40) {
+              var children = _ref40.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: {
+                    id: 42,
+                    name: 'Alpha'
+                  }
+                },
+                children: children
+              });
+            }
+          });
+          taskUrl = 'https://app.cor.com/tasks/55/detail';
+          _context38.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee37() {
+            var _streamCallbacks$onFi2, _streamCallbacks9;
+            return _regeneratorRuntime.wrap(function (_context37) {
+              while (1) switch (_context37.prev = _context37.next) {
+                case 0:
+                  _context37.next = 1;
+                  return (_streamCallbacks$onFi2 = (_streamCallbacks9 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi2 === void 0 ? void 0 : _streamCallbacks$onFi2.call(_streamCallbacks9, {
+                    sessionId: 'session-1',
+                    messageId: 'live-1',
+                    placeholderId: streamingPlaceholderMessageId('live-1')
+                  }, taskUrl, [], 'memory-task-1', null, ['Seguir'], null);
+                case 1:
+                case "end":
+                  return _context37.stop();
+              }
+            }, _callee37);
+          })));
+        case 1:
+          expect(addExistingTaskToDashboard).toHaveBeenCalledWith([55]);
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'answer-memory-task-1',
+            suggestions: ['Seguir']
+          }));
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: originalPathname
+            })
+          });
+          delete window.newProjectDashboard;
+        case 2:
+        case "end":
+          return _context38.stop();
+      }
+    }, _callee38);
+  })));
+  it('dispatches planner sync when hours charge approval completes', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee40() {
+    var onHoursCharged, event;
+    return _regeneratorRuntime.wrap(function (_context40) {
+      while (1) switch (_context40.prev = _context40.next) {
+        case 0:
+          onHoursCharged = jest.fn();
+          window.addEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged);
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-hours',
+            message: '¿Cargo horas?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'h1',
+                tool_name: 'create_hours',
+                tool_args: {}
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context40.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee39() {
+            var _streamCallbacks$onFi3, _streamCallbacks0;
+            return _regeneratorRuntime.wrap(function (_context39) {
+              while (1) switch (_context39.prev = _context39.next) {
+                case 0:
+                  _context39.next = 1;
+                  return (_streamCallbacks$onFi3 = (_streamCallbacks0 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi3 === void 0 ? void 0 : _streamCallbacks$onFi3.call(_streamCallbacks0, {
+                    sessionId: 'session-1',
+                    messageId: 'hours-1',
+                    placeholderId: streamingPlaceholderMessageId('hours-1')
+                  }, 'Horas cargadas', [], 'memory-hours-1');
+                case 1:
+                case "end":
+                  return _context39.stop();
+              }
+            }, _callee39);
+          })));
+        case 1:
+          expect(onHoursCharged).toHaveBeenCalled();
+          event = onHoursCharged.mock.calls[0][0];
+          expect(event.detail.tools).toEqual(['create_hours']);
+          window.removeEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged);
+        case 2:
+        case "end":
+          return _context40.stop();
+      }
+    }, _callee40);
+  })));
+  it('fetches and merges a newly created agent after stream finish', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee42() {
+    var onMergeAgent;
+    return _regeneratorRuntime.wrap(function (_context42) {
+      while (1) switch (_context42.prev = _context42.next) {
+        case 0:
+          window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true;
+          fetchAgentDetailMock.mockResolvedValue({
+            id: 'agent-new',
+            name: 'Nuevo'
+          });
+          onMergeAgent = jest.fn();
+          document.addEventListener('maia-merge-created-agent-into-list', onMergeAgent);
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-agent',
+            message: '¿Creo el agente?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'a1',
+                tool_name: 'create_agent',
+                tool_args: {}
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context42.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee41() {
+            var _streamCallbacks$onFi4, _streamCallbacks1;
+            return _regeneratorRuntime.wrap(function (_context41) {
+              while (1) switch (_context41.prev = _context41.next) {
+                case 0:
+                  _context41.next = 1;
+                  return (_streamCallbacks$onFi4 = (_streamCallbacks1 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi4 === void 0 ? void 0 : _streamCallbacks$onFi4.call(_streamCallbacks1, {
+                    sessionId: 'session-1',
+                    messageId: 'agent-live',
+                    placeholderId: streamingPlaceholderMessageId('agent-live')
+                  }, 'Agente creado', [], 'memory-agent-1', null, null, 'agent-new');
+                case 1:
+                  _context41.next = 2;
+                  return Promise.resolve();
+                case 2:
+                case "end":
+                  return _context41.stop();
+              }
+            }, _callee41);
+          })));
+        case 1:
+          expect(fetchAgentDetailMock).toHaveBeenCalledWith('agent-new');
+          expect(onMergeAgent).toHaveBeenCalled();
+          document.removeEventListener('maia-merge-created-agent-into-list', onMergeAgent);
+          window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false;
+        case 2:
+        case "end":
+          return _context42.stop();
+      }
+    }, _callee42);
+  })));
+  it('refetches the open task panel after an approved task edit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee44() {
+    var refetchTask;
+    return _regeneratorRuntime.wrap(function (_context44) {
+      while (1) switch (_context44.prev = _context44.next) {
+        case 0:
+          refetchTask = jest.fn();
+          window.taskPanel = {
+            taskId: 88,
+            refetchTask: refetchTask
+          };
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-edit',
+            message: '¿Edito?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'e1',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 88
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context44.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee43() {
+            var _streamCallbacks$onFi5, _streamCallbacks10;
+            return _regeneratorRuntime.wrap(function (_context43) {
+              while (1) switch (_context43.prev = _context43.next) {
+                case 0:
+                  _context43.next = 1;
+                  return (_streamCallbacks$onFi5 = (_streamCallbacks10 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi5 === void 0 ? void 0 : _streamCallbacks$onFi5.call(_streamCallbacks10, {
+                    sessionId: 'session-1',
+                    messageId: 'edit-live',
+                    placeholderId: streamingPlaceholderMessageId('edit-live')
+                  }, 'Tarea actualizada', [], 'memory-edit-1');
+                case 1:
+                case "end":
+                  return _context43.stop();
+              }
+            }, _callee43);
+          })));
+        case 1:
+          expect(refetchTask).toHaveBeenCalled();
+          delete window.taskPanel;
+        case 2:
+        case "end":
+          return _context44.stop();
+      }
+    }, _callee44);
+  })));
+  it('reloads messages when the active session ends with a stale streaming placeholder', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee46() {
+    return _regeneratorRuntime.wrap(function (_context46) {
+      while (1) switch (_context46.prev = _context46.next) {
+        case 0:
+          useSessionsStore.setState({
+            meta: {
+              'session-1': {
+                status: 'complete',
+                finishedAt: '2024-06-01T00:00:00.000Z'
+              }
+            },
+            messages: {
+              'session-1': [{
+                id: streamingPlaceholderMessageId('stale'),
+                message: '',
+                role: ChatHistoryRole.ASSISTANT,
+                user: {
+                  id: 'assistant',
+                  name: 'MAIA'
+                },
+                date: new Date()
+              }]
+            }
+          });
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context46.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee45() {
+            return _regeneratorRuntime.wrap(function (_context45) {
+              while (1) switch (_context45.prev = _context45.next) {
+                case 0:
+                  _context45.next = 1;
+                  return Promise.resolve();
+                case 1:
+                case "end":
+                  return _context45.stop();
+              }
+            }, _callee45);
+          })));
+        case 1:
+          expect(chatMessagesState.loadMessages).toHaveBeenCalledWith({
+            force: true
+          });
+        case 2:
+        case "end":
+          return _context46.stop();
+      }
+    }, _callee46);
+  })));
+  it('rotates to a fresh session id when initial chat id clears', function () {
+    var _renderHook21 = renderHook(function (_ref50) {
+        var chatId = _ref50.chatId;
+        return useChatManager({
+          chatId: chatId,
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper,
+        initialProps: {
+          chatId: 'previous-session'
+        }
+      }),
+      rerender = _renderHook21.rerender;
+    rerender({
+      chatId: null
+    });
+    expect(getChatsStoreState().setActiveChatId).toHaveBeenCalledWith(null);
+  });
+  it('restores the message list when a retry stream fails on the active session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee48() {
+    var dispatchSpy, _renderHook22, result;
+    return _regeneratorRuntime.wrap(function (_context48) {
+      while (1) switch (_context48.prev = _context48.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-1',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-stream-1-cancelled',
+            message: 'Respuesta parcial',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date(),
+            isFrontendCancelled: true
+          }];
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          activeView.set('session-1');
+          _renderHook22 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook22.result;
+          _context48.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee47() {
+            return _regeneratorRuntime.wrap(function (_context47) {
+              while (1) switch (_context47.prev = _context47.next) {
+                case 0:
+                  _context47.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context47.stop();
+              }
+            }, _callee47);
+          })));
+        case 1:
+          replaceMessagesMock.mockClear();
+          act(function () {
+            var _streamCallbacks$onEr7, _streamCallbacks11;
+            (_streamCallbacks$onEr7 = (_streamCallbacks11 = streamCallbacks).onError) === null || _streamCallbacks$onEr7 === void 0 || _streamCallbacks$onEr7.call(_streamCallbacks11, {
+              sessionId: 'session-1',
+              messageId: 'retry-1',
+              placeholderId: 'answer-retry-1-streaming'
+            }, 'server_error');
+          });
+          expect(replaceMessagesMock).toHaveBeenCalledWith(chatMessagesState.messages);
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event',
+            detail: expect.objectContaining({
+              severity: 'error'
+            })
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context48.stop();
+      }
+    }, _callee48);
+  })));
+  it('commits assistant attachments when an active stream finishes', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee50() {
+    var attachment;
+    return _regeneratorRuntime.wrap(function (_context50) {
+      while (1) switch (_context50.prev = _context50.next) {
+        case 0:
+          activeView.set('session-1');
+          useSessionsStore.setState({
+            messages: {
+              'session-1': [{
+                id: streamingPlaceholderMessageId('live-attach'),
+                message: '',
+                role: ChatHistoryRole.ASSISTANT,
+                user: {
+                  id: 'assistant',
+                  name: 'MAIA'
+                },
+                date: new Date()
+              }]
+            }
+          });
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          attachment = {
+            id: 'att-1',
+            name: 'brief.pdf',
+            type: 'pdf',
+            size: 10,
+            file: new File([], 'brief.pdf')
+          };
+          _context50.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee49() {
+            var _streamCallbacks$onFi6, _streamCallbacks12;
+            return _regeneratorRuntime.wrap(function (_context49) {
+              while (1) switch (_context49.prev = _context49.next) {
+                case 0:
+                  _context49.next = 1;
+                  return (_streamCallbacks$onFi6 = (_streamCallbacks12 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi6 === void 0 ? void 0 : _streamCallbacks$onFi6.call(_streamCallbacks12, {
+                    sessionId: 'session-1',
+                    messageId: 'live-attach',
+                    placeholderId: streamingPlaceholderMessageId('live-attach')
+                  }, 'Respuesta con adjunto', [], 'memory-attach-1', [attachment], null, null);
+                case 1:
+                case "end":
+                  return _context49.stop();
+              }
+            }, _callee49);
+          })));
+        case 1:
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'answer-memory-attach-1',
+            attachments: expect.arrayContaining([expect.objectContaining({
+              id: 'att-1',
+              name: 'brief.pdf'
+            })])
+          }));
+        case 2:
+        case "end":
+          return _context50.stop();
+      }
+    }, _callee50);
+  })));
+  it('syncs task deletion on the project dashboard after approval', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee52() {
+    var deleteExistingTaskFromDashboard, originalPathname;
+    return _regeneratorRuntime.wrap(function (_context52) {
+      while (1) switch (_context52.prev = _context52.next) {
+        case 0:
+          deleteExistingTaskFromDashboard = jest.fn();
+          window.newProjectDashboard = {
+            deleteExistingTaskFromDashboard: deleteExistingTaskFromDashboard
+          };
+          originalPathname = window.location.pathname;
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: '/projects/42/tasks'
+            })
+          });
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-delete',
+            message: '¿Elimino la tarea?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'd1',
+                tool_name: 'delete_task',
+                tool_args: {
+                  task_id: 77
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref56) {
+              var children = _ref56.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: {
+                    id: 42,
+                    name: 'Alpha'
+                  }
+                },
+                children: children
+              });
+            }
+          });
+          _context52.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee51() {
+            var _streamCallbacks$onFi7, _streamCallbacks13;
+            return _regeneratorRuntime.wrap(function (_context51) {
+              while (1) switch (_context51.prev = _context51.next) {
+                case 0:
+                  _context51.next = 1;
+                  return (_streamCallbacks$onFi7 = (_streamCallbacks13 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi7 === void 0 ? void 0 : _streamCallbacks$onFi7.call(_streamCallbacks13, {
+                    sessionId: 'session-1',
+                    messageId: 'delete-live',
+                    placeholderId: streamingPlaceholderMessageId('delete-live')
+                  }, 'Tarea eliminada', [], 'memory-delete-1');
+                case 1:
+                case "end":
+                  return _context51.stop();
+              }
+            }, _callee51);
+          })));
+        case 1:
+          expect(deleteExistingTaskFromDashboard).toHaveBeenCalledWith([77]);
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: originalPathname
+            })
+          });
+          delete window.newProjectDashboard;
+        case 2:
+        case "end":
+          return _context52.stop();
+      }
+    }, _callee52);
+  })));
+  it('commits a pending approval message on the active session', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp, _streamCallbacks14;
+      (_streamCallbacks$onAp = (_streamCallbacks14 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp === void 0 || _streamCallbacks$onAp.call(_streamCallbacks14, {
+        sessionId: 'session-1',
+        messageId: 'live-hitl',
+        placeholderId: streamingPlaceholderMessageId('live-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-1',
+        original_thread_id: 'orig-1',
+        pending_actions: [{
+          thread_id: 't1',
+          tool_name: 'edit_task',
+          tool_args: {
+            task_id: 1
+          },
+          tool_call_id: 'c1'
+        }],
+        total_actions: 1,
+        metadata: {}
+      }, '¿Confirmás la edición?');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      approvalStatus: 'pending',
+      message: '¿Confirmás la edición?'
+    }));
+  });
+  it('does not paint approval UI when the stream was auto-approved', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp2, _streamCallbacks15;
+      (_streamCallbacks$onAp2 = (_streamCallbacks15 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp2 === void 0 || _streamCallbacks$onAp2.call(_streamCallbacks15, {
+        sessionId: 'session-1',
+        messageId: 'auto-hitl',
+        placeholderId: streamingPlaceholderMessageId('auto-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-1',
+        original_thread_id: 'orig-auto',
+        pending_actions: [{
+          thread_id: 't-auto',
+          tool_name: 'create_task',
+          tool_args: {},
+          tool_call_id: 'c-auto'
+        }],
+        total_actions: 1,
+        metadata: {},
+        auto_approved: true
+      }, 'Creando tarea');
+    });
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+  it('marks background sessions unread when approval is required off-screen', function () {
+    activeView.set('session-visible');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-visible',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp3, _streamCallbacks16;
+      (_streamCallbacks$onAp3 = (_streamCallbacks16 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp3 === void 0 || _streamCallbacks$onAp3.call(_streamCallbacks16, {
+        sessionId: 'session-bg',
+        messageId: 'bg-hitl',
+        placeholderId: streamingPlaceholderMessageId('bg-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-bg',
+        original_thread_id: 'orig-bg',
+        pending_actions: [{
+          thread_id: 't-bg',
+          tool_name: 'edit_task',
+          tool_args: {},
+          tool_call_id: 'c-bg'
+        }],
+        total_actions: 1,
+        metadata: {}
+      }, 'Aprobación pendiente');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'approval_required');
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+  it('clears pinned context when switching to another existing chat', function () {
+    var setProject = jest.fn();
+    var setClient = jest.fn();
+    var setChipsProject = jest.fn();
+    var setTask = jest.fn();
+    var contextWrapper = function contextWrapper(_ref58) {
+      var children = _ref58.children;
+      return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+        value: {
+          agent: testAgent,
+          setProject: setProject,
+          setClient: setClient,
+          setChipsProject: setChipsProject,
+          setTask: setTask
+        },
+        children: children
+      });
+    };
+    var _renderHook23 = renderHook(function (_ref59) {
+        var chatId = _ref59.chatId;
+        return useChatManager({
+          chatId: chatId,
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: contextWrapper,
+        initialProps: {
+          chatId: 'session-a'
+        }
+      }),
+      rerender = _renderHook23.rerender;
+    sessionStreamManager.isActive.mockReturnValue(true);
+    rerender({
+      chatId: 'session-b'
+    });
+    expect(setProject).toHaveBeenCalledWith(null);
+    expect(setClient).toHaveBeenCalledWith(null);
+    expect(setChipsProject).toHaveBeenCalledWith(null);
+    expect(setTask).toHaveBeenCalledWith(null);
+  });
+  it('commits partial assistant text when the stream stops mid-response', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    var ctx = {
+      sessionId: 'session-1',
+      messageId: 'live-stop-1',
+      placeholderId: streamingPlaceholderMessageId('live-stop-1')
+    };
+    act(function () {
+      var _streamCallbacks$onSt2, _streamCallbacks17;
+      (_streamCallbacks$onSt2 = (_streamCallbacks17 = streamCallbacks).onStreamUpdate) === null || _streamCallbacks$onSt2 === void 0 || _streamCallbacks$onSt2.call(_streamCallbacks17, ctx, 'Parcial');
+    });
+    act(function () {
+      var _streamCallbacks$onSt3, _streamCallbacks18;
+      (_streamCallbacks$onSt3 = (_streamCallbacks18 = streamCallbacks).onStop) === null || _streamCallbacks$onSt3 === void 0 || _streamCallbacks$onSt3.call(_streamCallbacks18, 'Parcial');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      message: 'Parcial',
+      role: ChatHistoryRole.ASSISTANT
+    }));
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      role: ChatHistoryRole.ASSISTANT,
+      message: expect.stringMatching(/cancel/i)
+    }));
+  });
+  it('replays via orchestrator when retryCompletion reports turn_not_found', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee54() {
+    var _renderHook24, result;
+    return _regeneratorRuntime.wrap(function (_context54) {
+      while (1) switch (_context54.prev = _context54.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-retry',
+            message: '¿Status?',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-abc',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-abc'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'turn_not_found'
+          });
+          _renderHook24 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook24.result;
+          _context54.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee53() {
+            return _regeneratorRuntime.wrap(function (_context53) {
+              while (1) switch (_context53.prev = _context53.next) {
+                case 0:
+                  _context53.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context53.stop();
+              }
+            }, _callee53);
+          })));
+        case 1:
+          expect(retryCompletionMock).toHaveBeenCalled();
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: '¿Status?'
+          }));
+        case 2:
+        case "end":
+          return _context54.stop();
+      }
+    }, _callee54);
+  })));
+  it('shows a snackbar when retryCompletion hits the concurrent stream limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee56() {
+    var dispatchSpy, _renderHook25, result;
+    return _regeneratorRuntime.wrap(function (_context56) {
+      while (1) switch (_context56.prev = _context56.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-limit',
+            message: 'Retry me',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-limit',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-limit'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook25 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook25.result;
+          _context56.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee55() {
+            return _regeneratorRuntime.wrap(function (_context55) {
+              while (1) switch (_context55.prev = _context55.next) {
+                case 0:
+                  _context55.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context55.stop();
+              }
+            }, _callee55);
+          })));
+        case 1:
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event',
+            detail: expect.objectContaining({
+              message: expect.any(String)
+            })
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context56.stop();
+      }
+    }, _callee56);
+  })));
+  it('shows a snackbar when replayViaOrchestrator hits the concurrent stream limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee58() {
+    var dispatchSpy, _renderHook26, result;
+    return _regeneratorRuntime.wrap(function (_context58) {
+      while (1) switch (_context58.prev = _context58.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-replay-limit',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-replay-limit',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-replay-limit'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'turn_not_found'
+          });
+          askMaiaMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook26 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook26.result;
+          _context58.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee57() {
+            return _regeneratorRuntime.wrap(function (_context57) {
+              while (1) switch (_context57.prev = _context57.next) {
+                case 0:
+                  _context57.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context57.stop();
+              }
+            }, _callee57);
+          })));
+        case 1:
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context58.stop();
+      }
+    }, _callee58);
+  })));
+  it('shows a snackbar when approval continue stream fails to start due to limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee60() {
+    var dispatchSpy, _renderHook27, result;
+    return _regeneratorRuntime.wrap(function (_context60) {
+      while (1) switch (_context60.prev = _context60.next) {
+        case 0:
+          activeView.set('session-1');
+          startContinueStreamMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          chatMessagesState.messages = [{
+            id: 'msg-approval-limit',
+            message: 'Approve?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-limit',
+                tool_name: 'edit_task',
+                tool_args: {}
+              }]
+            }
+          }];
+          _renderHook27 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook27.result;
+          _context60.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee59() {
+            return _regeneratorRuntime.wrap(function (_context59) {
+              while (1) switch (_context59.prev = _context59.next) {
+                case 0:
+                  _context59.next = 1;
+                  return result.current.handleApprovalDecision(['thread-limit'], 'approve');
+                case 1:
+                case "end":
+                  return _context59.stop();
+              }
+            }, _callee59);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context60.stop();
+      }
+    }, _callee60);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","GlobalContextTestProvider","testAgent","useSessionsStore","sessionStreamManager","ChatHistoryRole","Feedback","maia","activeView","useOrchestratorStream","getChatsStoreState","notifySessionFinishedInBackground","fetchAgentDetail","MAIA_HOURS_CHARGED_EVENT","streamingPlaceholderMessageId","useChatManager","jsx","_jsx","fetchAgentDetailMock","mockUseOrchestratorStream","streamCallbacks","startContinueStreamMock","jest","fn","mockResolvedValue","started","askMaiaMock","retryCompletionMock","stopStreamingMock","replaceMessagesMock","addMessageMock","eventMock","chatMessagesState","loadingMessages","messages","isLoadingMoreMessages","loadMessages","addMessage","removeMessage","replaceMessages","handleScroll","mock","useChatMessages","useProjects","fetchProjects","useTabTaskDefault","getTabTaskDefault","EVENTS","pmAiTypedText","useEvent","useUser","id","firstName","lastName","picture","lang","company_id","state","setActiveChatId","markChatAsRead","markChatAsUnread","isChatViewVisible","chats","prependChat","useChatsStore","selector","Object","assign","getState","__esModule","Chats","wasHelpfulChat","ensureSessionNotificationsInitialized","isActive","getActiveCount","startStream","startContinueStream","apply","arguments","stopStream","MAX_CONCURRENT_STREAMS","wrapper","_ref","children","value","agent","describe","beforeEach","clearAllMocks","mockImplementation","options","onError","onStreamUpdate","onStop","onApprovalRequired","onFinishStream","askMaia","retryCompletion","isLoading","isWriting","loadingMessage","streamActivity","updateStreamActivity","stopStreaming","setState","meta","viewCache","set","mockReturnValue","it","_renderHook","chatId","agents","result","expect","current","toEqual","isDisabled","toBe","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_renderHook2","wrap","_context2","prev","next","_callee","_context","sendMessage","stop","toHaveBeenCalledWith","objectContaining","message","agentId","agentName","name","role","_callee4","dispatchSpy","_renderHook3","_context4","spyOn","document","_callee3","_context3","not","toHaveBeenCalled","type","mockRestore","_renderHook4","stopGeneration","_renderHook5","resetChat","currentChatId","_callee6","_renderHook6","_context6","_callee5","_context5","_callee8","_renderHook7","_context8","_callee7","_context7","mentions","label","contextMessage","user","arrayContaining","_callee0","_renderHook8","_context0","USER","date","Date","ASSISTANT","isFrontendCancelled","_callee9","_context9","retryMessage","_callee10","setProject","project","_renderHook9","_context10","_ref11","_callee1","_context1","mockClear","changeProject","feeId","clientId","projectId","_renderHook0","_callee12","_renderHook1","_context12","approval","session_id","pending_actions","thread_id","tool_name","tool_args","task_id","_callee11","_context11","handleApprovalDecision","continueRequest","decision","_callee14","_renderHook10","_context14","_callee13","_context13","sessionId","threadIds","_callee16","_renderHook11","_context16","mocked","_callee15","_context15","handleFeedback","THUMBS_UP","_callee18","_renderHook12","_context18","_callee17","_context17","THUMBS_DOWN","toHaveProperty","_callee20","consoleSpy","_renderHook13","_context20","console","undefined","_callee19","_context19","_callee22","attachment","_renderHook14","_context22","size","file","File","_callee21","_context21","attachments","_callee24","_renderHook15","_context24","_callee23","_context23","initializeChat","_callee26","_renderHook16","_context26","userInitialMessage","faqId","_callee25","_context25","_callee28","_renderHook17","_context28","_callee27","_context27","_callee30","_renderHook18","_context30","_callee29","_context29","_callee32","_renderHook19","_context32","_callee31","_context31","_callee34","editedActions","_renderHook20","_context34","args","_callee33","_context33","_streamCallbacks$onEr","_streamCallbacks","call","messageId","placeholderId","isError","suggestions","_streamCallbacks$onEr2","_streamCallbacks2","_streamCallbacks$onEr3","_streamCallbacks3","_streamCallbacks$onEr4","_streamCallbacks4","ctx","_streamCallbacks$onSt","_streamCallbacks5","getMessages","_callee36","_context36","_callee35","_streamCallbacks$onFi","_streamCallbacks6","_context35","_streamCallbacks$onEr5","_streamCallbacks7","stringContaining","_streamCallbacks$onEr6","_streamCallbacks8","_callee38","addExistingTaskToDashboard","originalPathname","taskUrl","_context38","window","newProjectDashboard","location","pathname","defineProperty","configurable","_objectSpread","approvalStatus","_ref40","_callee37","_streamCallbacks$onFi2","_streamCallbacks9","_context37","_callee40","onHoursCharged","event","_context40","addEventListener","_callee39","_streamCallbacks$onFi3","_streamCallbacks0","_context39","calls","detail","tools","removeEventListener","_callee42","onMergeAgent","_context42","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","_callee41","_streamCallbacks$onFi4","_streamCallbacks1","_context41","Promise","resolve","_callee44","refetchTask","_context44","taskPanel","taskId","_callee43","_streamCallbacks$onFi5","_streamCallbacks10","_context43","_callee46","_context46","status","finishedAt","_callee45","_context45","force","_renderHook21","_ref50","initialProps","rerender","_callee48","_renderHook22","_context48","_callee47","_context47","_streamCallbacks$onEr7","_streamCallbacks11","severity","_callee50","_context50","_callee49","_streamCallbacks$onFi6","_streamCallbacks12","_context49","_callee52","deleteExistingTaskFromDashboard","_context52","_ref56","_callee51","_streamCallbacks$onFi7","_streamCallbacks13","_context51","_streamCallbacks$onAp","_streamCallbacks14","original_thread_id","tool_call_id","total_actions","metadata","_streamCallbacks$onAp2","_streamCallbacks15","auto_approved","_streamCallbacks$onAp3","_streamCallbacks16","setClient","setChipsProject","setTask","contextWrapper","_ref58","_renderHook23","_ref59","_streamCallbacks$onSt2","_streamCallbacks17","_streamCallbacks$onSt3","_streamCallbacks18","stringMatching","_callee54","_renderHook24","_context54","memorySessionId","reason","_callee53","_context53","_callee56","_renderHook25","_context56","_callee55","_context55","any","String","_callee58","_renderHook26","_context58","_callee57","_context57","_callee60","_renderHook27","_context60","_callee59","_context59"],"sources":["../../../src/hooks/useChatManager/useChatManager.spec.tsx"],"sourcesContent":["import { ReactNode } from 'react'\nimport { act, renderHook } from '@testing-library/react'\nimport { GlobalContextTestProvider, testAgent } from '../../test/global-context'\nimport { useSessionsStore } from '../../store/sessions/useSessionsStore'\nimport { sessionStreamManager } from '../../store/sessions/sessionStreamManager'\nimport { ApprovalRequest, ChatHistoryRole, ChatMessage } from '../../types/Chat'\nimport { Feedback } from '../../components/molecules/MessageFeedback/MessageFeedback'\nimport maia from '../../services/maia'\nimport { activeView } from '../../store/sessions/activeView'\nimport { useOrchestratorStream } from '../useOrchestratorStream'\nimport type { StreamContext } from '../useOrchestratorStream/useOrchestratorStream.interface'\nimport { getChatsStoreState } from '../../store/useChatsStore'\nimport { notifySessionFinishedInBackground } from '../../store/sessions/sessionNotifications'\nimport { fetchAgentDetail } from '../../services/maia/Agents/fetchAgentDetail'\nimport { MAIA_HOURS_CHARGED_EVENT } from '../../constants/plannerSyncEvents'\nimport { streamingPlaceholderMessageId } from '../../utils/streamActivityMessages'\nimport { useChatManager } from './useChatManager'\n\nconst fetchAgentDetailMock = fetchAgentDetail as jest.MockedFunction<typeof fetchAgentDetail>\n\nconst mockUseOrchestratorStream = useOrchestratorStream as jest.MockedFunction<typeof useOrchestratorStream>\n\ntype CapturedStreamCallbacks = {\n  onError?: (ctx: StreamContext, errorMessage?: string, errorRawMessage?: string) => void\n  onStreamUpdate?: (ctx: StreamContext, content: string) => void\n  onStop?: (partialText: string) => void\n  onApprovalRequired?: (ctx: StreamContext, approval: ApprovalRequest, content: string) => void\n  onFinishStream?: (\n    ctx: StreamContext,\n    content: string,\n    sources: unknown,\n    memorySessionId: string,\n    attachments?: unknown[] | null,\n    suggestions?: string[] | null,\n    agentId?: string | null\n  ) => void | Promise<void>\n}\n\nlet streamCallbacks: CapturedStreamCallbacks = {}\n\nconst startContinueStreamMock = jest.fn().mockResolvedValue({ started: true })\n\nconst askMaiaMock = jest.fn().mockResolvedValue({ started: true })\nconst retryCompletionMock = jest.fn().mockResolvedValue({ started: true })\nconst stopStreamingMock = jest.fn()\nconst replaceMessagesMock = jest.fn()\nconst addMessageMock = jest.fn()\nconst eventMock = jest.fn()\n\nconst chatMessagesState = {\n  loadingMessages: false,\n  messages: [] as ChatMessage[],\n  isLoadingMoreMessages: false,\n  loadMessages: jest.fn(),\n  addMessage: addMessageMock,\n  removeMessage: jest.fn(),\n  replaceMessages: replaceMessagesMock,\n  handleScroll: jest.fn(),\n}\n\njest.mock('../useChatMessages', () => ({\n  useChatMessages: () => chatMessagesState,\n}))\n\njest.mock('../useOrchestratorStream', () => ({\n  useOrchestratorStream: jest.fn(),\n}))\n\njest.mock('../useProjects', () => ({\n  useProjects: () => ({\n    fetchProjects: jest.fn().mockResolvedValue([]),\n  }),\n}))\n\njest.mock('../useTabTaskDefault', () => ({\n  useTabTaskDefault: () => ({\n    getTabTaskDefault: jest.fn().mockResolvedValue('detail'),\n  }),\n}))\n\njest.mock('../useEvent', () => ({\n  EVENTS: { pmAiTypedText: 'PM_AI_TYPED_TEXT' },\n  useEvent: () => eventMock,\n}))\n\njest.mock('../../context/cor-user', () => ({\n  useUser: () => ({\n    id: 7,\n    firstName: 'Ana',\n    lastName: 'García',\n    picture: 'pic.png',\n    lang: 'es',\n    company_id: 10,\n  }),\n}))\n\njest.mock('../../store/useChatsStore', () => {\n  const state = {\n    setActiveChatId: jest.fn(),\n    markChatAsRead: jest.fn(),\n    markChatAsUnread: jest.fn(),\n    isChatViewVisible: true,\n    chats: [] as Array<{ sessionExternalId: string }>,\n    prependChat: jest.fn(),\n  }\n  const useChatsStore = (selector: (value: typeof state) => unknown) => selector(state)\n  Object.assign(useChatsStore, { getState: () => state })\n\n  return {\n    useChatsStore,\n    getChatsStoreState: () => state,\n  }\n})\n\njest.mock('../../services/maia', () => ({\n  __esModule: true,\n  default: {\n    Chats: {\n      wasHelpfulChat: jest.fn(),\n    },\n  },\n}))\n\njest.mock('../../services/maia/Agents/fetchAgentDetail', () => ({\n  fetchAgentDetail: jest.fn(),\n}))\n\njest.mock('../../store/sessions/sessionNotifications', () => ({\n  notifySessionFinishedInBackground: jest.fn(),\n  ensureSessionNotificationsInitialized: jest.fn(),\n}))\n\njest.mock('../../store/sessions/sessionStreamManager', () => ({\n  sessionStreamManager: {\n    isActive: jest.fn(() => false),\n    getActiveCount: jest.fn(() => 0),\n    startStream: jest.fn(),\n    startContinueStream: (...args: unknown[]) => startContinueStreamMock(...args),\n    stopStream: jest.fn(),\n  },\n  MAX_CONCURRENT_STREAMS: 3,\n}))\n\nconst wrapper = ({ children }: { children: ReactNode }) => (\n  <GlobalContextTestProvider value={{ agent: testAgent }}>{children}</GlobalContextTestProvider>\n)\n\ndescribe('useChatManager', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    streamCallbacks = {}\n    mockUseOrchestratorStream.mockImplementation(options => {\n      streamCallbacks = {\n        onError: options.onError,\n        onStreamUpdate: options.onStreamUpdate,\n        onStop: options.onStop,\n        onApprovalRequired: options.onApprovalRequired,\n        onFinishStream: options.onFinishStream,\n      }\n      return {\n        askMaia: askMaiaMock,\n        retryCompletion: retryCompletionMock,\n        isLoading: false,\n        isWriting: false,\n        loadingMessage: '',\n        streamActivity: null,\n        updateStreamActivity: jest.fn(),\n        stopStreaming: stopStreamingMock,\n      }\n    })\n    chatMessagesState.loadingMessages = false\n    chatMessagesState.messages = []\n    useSessionsStore.setState({ meta: {}, messages: {}, viewCache: {} })\n    activeView.set(null)\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(false)\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(0)\n    startContinueStreamMock.mockResolvedValue({ started: true })\n    askMaiaMock.mockResolvedValue({ started: true })\n    retryCompletionMock.mockResolvedValue({ started: true })\n  })\n\n  it('starts with empty messages and send enabled', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    expect(result.current.messages).toEqual([])\n    expect(result.current.isDisabled).toBe(false)\n  })\n\n  it('sendMessage delegates to askMaia with the current session', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola MAIA')\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola MAIA',\n        chatId: 'session-1',\n        agentId: testAgent.id,\n        agentName: testAgent.name,\n      })\n    )\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola MAIA',\n        role: 'user',\n      })\n    )\n  })\n\n  it('does not send when the concurrent stream limit is reached', async () => {\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(3)\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola')\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('stopGeneration stops the active stream', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.stopGeneration()\n    })\n\n    expect(stopStreamingMock).toHaveBeenCalled()\n  })\n\n  it('resetChat clears the active chat id in the store hook path', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.resetChat()\n    })\n\n    expect(result.current.currentChatId).not.toBe('session-1')\n  })\n\n  it('does not send while messages are loading', async () => {\n    chatMessagesState.loadingMessages = true\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    expect(result.current.isDisabled).toBe(true)\n\n    await act(async () => {\n      await result.current.sendMessage('Hola')\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n  })\n\n  it('includes context mentions when they are sent via options', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola', {\n        mentions: [{ id: 'u1', type: 'user', label: 'Ana' }],\n      })\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        contextMessage: expect.objectContaining({\n          user: expect.arrayContaining([expect.objectContaining({ id: 'u1', name: 'Ana' })]),\n        }),\n      })\n    )\n    expect(eventMock).toHaveBeenCalledWith('PM_AI_TYPED_TEXT')\n  })\n\n  it('retries a cancelled assistant turn through askMaia', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-1',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-stream-1-cancelled',\n        message: 'Respuesta parcial',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n        isFrontendCancelled: true,\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola',\n        chatId: 'session-1',\n      })\n    )\n    expect(replaceMessagesMock).toHaveBeenCalled()\n  })\n\n  it('re-asks with the new project when a pending question exists', async () => {\n    const setProject = jest.fn()\n    const project = { id: 10, name: 'Proyecto A' } as never\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }: { children: ReactNode }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project, setProject }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('¿Cuántas horas van?')\n    })\n\n    askMaiaMock.mockClear()\n\n    act(() => {\n      result.current.changeProject({ id: 99, name: 'Proyecto X', feeId: 5, clientId: 7 } as never)\n    })\n\n    expect(setProject).toHaveBeenCalledWith(expect.objectContaining({ id: 99 }))\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: '¿Cuántas horas van?',\n        projectId: 99,\n        feeId: 5,\n        clientId: 7,\n      })\n    )\n  })\n\n  it('does not change project when there is no pending user question', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.changeProject({ id: 99, name: 'Proyecto X' } as never)\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n  })\n\n  it('starts a continue stream when rejecting a HITL action', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'reject')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        continueRequest: expect.objectContaining({\n          decision: 'reject',\n        }),\n      })\n    )\n  })\n\n  it('starts a continue stream when approving a HITL action', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'approve')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        sessionId: 'session-1',\n        continueRequest: expect.objectContaining({\n          threadIds: ['thread-a'],\n          decision: 'approve',\n        }),\n      })\n    )\n  })\n\n  it('submits feedback through the maia chats service', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'answer-1',\n        message: 'Respuesta',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n      },\n    ]\n\n    jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(true)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleFeedback(Feedback.THUMBS_UP, 'answer-1')\n    })\n\n    expect(maia.Chats.wasHelpfulChat).toHaveBeenCalledWith('answer-1', true)\n  })\n\n  it('ignores feedback updates when the API rejects the vote', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'answer-1',\n        message: 'Respuesta',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n      },\n    ]\n\n    jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(false)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleFeedback(Feedback.THUMBS_DOWN, 'answer-1')\n    })\n\n    expect(chatMessagesState.messages[0]).not.toHaveProperty('wasHelpful')\n  })\n\n  it('does not start approval streams without thread ids', async () => {\n    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision([], 'approve')\n    })\n\n    expect(startContinueStreamMock).not.toHaveBeenCalled()\n    expect(consoleSpy).toHaveBeenCalled()\n\n    consoleSpy.mockRestore()\n  })\n\n  it('sendMessage accepts a bare attachments array', async () => {\n    const attachment = { id: 'a1', name: 'doc.pdf', type: 'pdf', size: 1, file: new File([], 'doc.pdf') }\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Con adjunto', [attachment])\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Con adjunto',\n        attachments: [attachment],\n      })\n    )\n  })\n\n  it('loads messages when initializeChat runs with an existing chat id', async () => {\n    chatMessagesState.loadMessages.mockResolvedValue(undefined)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(chatMessagesState.loadMessages).toHaveBeenCalled()\n  })\n\n  it('auto-sends the initial FAQ when initializeChat receives faqId only', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          userInitialMessage: { message: '', attachments: [], faqId: 'faq-rentabilidad' },\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({ faqId: 'faq-rentabilidad' }))\n  })\n\n  it('skips initializeChat auto-send when the initial payload is empty', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          userInitialMessage: { message: '   ', attachments: [] },\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(chatMessagesState.loadMessages).not.toHaveBeenCalled()\n  })\n\n  it('does not retry when the concurrent stream limit is reached', async () => {\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(3)\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    chatMessagesState.messages = [\n      {\n        id: 'question-1',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-stream-1-cancelled',\n        message: 'Respuesta parcial',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n        isFrontendCancelled: true,\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('does not start approval streams when the session is already streaming', async () => {\n    activeView.set('session-1')\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(true)\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: {} }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'approve')\n    })\n\n    expect(startContinueStreamMock).not.toHaveBeenCalled()\n  })\n\n  it('starts a continue stream with edit decision when actions were edited', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const editedActions = [{ tool_name: 'edit_task', args: { task_id: 99 } }]\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'reject', editedActions)\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        continueRequest: expect.objectContaining({\n          decision: 'edit',\n          editedActions,\n        }),\n      })\n    )\n  })\n\n  it('commits access denied stream errors without retry suggestions', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-err',\n          placeholderId: 'answer-msg-err-streaming',\n        },\n        \"Access denied: You don't have permission to access this agent\"\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: 'chat.errorAccessDenied',\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('maps prompt-too-long stream errors without retry suggestions', () => {\n    activeView.set('session-1')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-long',\n          placeholderId: 'answer-msg-long-streaming',\n        },\n        'invalid_request_error',\n        'prompt is too long: 12000 tokens'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: 'chat.errorPromptTooLong',\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('marks background sessions unread when a stream errors off-screen', () => {\n    activeView.set('session-visible')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-visible',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-bg',\n          messageId: 'bg-err',\n          placeholderId: 'answer-bg-err-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'error')\n  })\n\n  it('adds retry suggestions for generic stream errors on the active session', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-500',\n          placeholderId: 'answer-msg-500-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('creates the streaming placeholder on the first stream update', () => {\n    activeView.set('session-1')\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    const ctx: StreamContext = {\n      sessionId: 'session-1',\n      messageId: 'live-1',\n      placeholderId: 'answer-live-1-streaming',\n    }\n\n    act(() => {\n      streamCallbacks.onStreamUpdate?.(ctx, 'Generando')\n    })\n\n    expect(useSessionsStore.getState().getMessages('session-1')).toEqual(\n      expect.arrayContaining([expect.objectContaining({ id: 'answer-live-1-streaming', message: '' })])\n    )\n  })\n\n  it('marks background sessions unread when a stream finishes off-screen', async () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    activeView.set('session-visible')\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'bg-1',\n          placeholderId: 'answer-bg-1-streaming',\n        },\n        'Respuesta en background',\n        [],\n        'memory-bg-1',\n        null,\n        null,\n        null\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'complete')\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n\n  it('commits prompt-too-long stream errors without retry suggestions', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-long',\n          placeholderId: 'answer-msg-long-streaming',\n        },\n        'invalid_request_error',\n        'prompt is too long: 12000 tokens'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: expect.stringContaining('chat.errorPromptTooLong'),\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('marks background sessions unread when a stream errors off-screen', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    activeView.set('other-session')\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'bg-err',\n          placeholderId: 'answer-bg-err-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'error')\n  })\n\n  it('syncs task creation with the project dashboard when approval completes on the active session', async () => {\n    const addExistingTaskToDashboard = jest.fn()\n    window.newProjectDashboard = { addExistingTaskToDashboard }\n    const originalPathname = window.location.pathname\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: '/projects/42/tasks' },\n    })\n\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'user-1',\n        message: 'Crea la tarea',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n        projectId: 42,\n      },\n      {\n        id: 'approval-msg',\n        message: '¿Confirmás?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 't1', tool_name: 'create_task', tool_args: { task_id: 55 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project: { id: 42, name: 'Alpha' } as never }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    const taskUrl = 'https://app.cor.com/tasks/55/detail'\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-1',\n          placeholderId: streamingPlaceholderMessageId('live-1'),\n        },\n        taskUrl,\n        [],\n        'memory-task-1',\n        null,\n        ['Seguir'],\n        null\n      )\n    })\n\n    expect(addExistingTaskToDashboard).toHaveBeenCalledWith([55])\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        id: 'answer-memory-task-1',\n        suggestions: ['Seguir'],\n      })\n    )\n\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: originalPathname },\n    })\n    delete window.newProjectDashboard\n  })\n\n  it('dispatches planner sync when hours charge approval completes', async () => {\n    const onHoursCharged = jest.fn()\n    window.addEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged)\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-hours',\n        message: '¿Cargo horas?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'h1', tool_name: 'create_hours', tool_args: {} }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'hours-1',\n          placeholderId: streamingPlaceholderMessageId('hours-1'),\n        },\n        'Horas cargadas',\n        [],\n        'memory-hours-1'\n      )\n    })\n\n    expect(onHoursCharged).toHaveBeenCalled()\n    const event = onHoursCharged.mock.calls[0][0] as CustomEvent\n    expect(event.detail.tools).toEqual(['create_hours'])\n\n    window.removeEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged)\n  })\n\n  it('fetches and merges a newly created agent after stream finish', async () => {\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true\n    fetchAgentDetailMock.mockResolvedValue({ id: 'agent-new', name: 'Nuevo' } as never)\n    const onMergeAgent = jest.fn()\n    document.addEventListener('maia-merge-created-agent-into-list', onMergeAgent)\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-agent',\n        message: '¿Creo el agente?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'a1', tool_name: 'create_agent', tool_args: {} }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'agent-live',\n          placeholderId: streamingPlaceholderMessageId('agent-live'),\n        },\n        'Agente creado',\n        [],\n        'memory-agent-1',\n        null,\n        null,\n        'agent-new'\n      )\n      await Promise.resolve()\n    })\n\n    expect(fetchAgentDetailMock).toHaveBeenCalledWith('agent-new')\n    expect(onMergeAgent).toHaveBeenCalled()\n    document.removeEventListener('maia-merge-created-agent-into-list', onMergeAgent)\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false\n  })\n\n  it('refetches the open task panel after an approved task edit', async () => {\n    const refetchTask = jest.fn()\n    window.taskPanel = { taskId: 88, refetchTask }\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-edit',\n        message: '¿Edito?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'e1', tool_name: 'edit_task', tool_args: { task_id: 88 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'edit-live',\n          placeholderId: streamingPlaceholderMessageId('edit-live'),\n        },\n        'Tarea actualizada',\n        [],\n        'memory-edit-1'\n      )\n    })\n\n    expect(refetchTask).toHaveBeenCalled()\n    delete window.taskPanel\n  })\n\n  it('reloads messages when the active session ends with a stale streaming placeholder', async () => {\n    useSessionsStore.setState({\n      meta: { 'session-1': { status: 'complete', finishedAt: '2024-06-01T00:00:00.000Z' } },\n      messages: {\n        'session-1': [\n          {\n            id: streamingPlaceholderMessageId('stale'),\n            message: '',\n            role: ChatHistoryRole.ASSISTANT,\n            user: { id: 'assistant', name: 'MAIA' },\n            date: new Date(),\n          },\n        ],\n      },\n    })\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await Promise.resolve()\n    })\n\n    expect(chatMessagesState.loadMessages).toHaveBeenCalledWith({ force: true })\n  })\n\n  it('rotates to a fresh session id when initial chat id clears', () => {\n    const { rerender } = renderHook(\n      ({ chatId }: { chatId: string | null }) =>\n        useChatManager({\n          chatId,\n          agents: [testAgent],\n        }),\n      {\n        wrapper,\n        initialProps: { chatId: 'previous-session' as string | null },\n      }\n    )\n\n    rerender({ chatId: null })\n\n    expect(getChatsStoreState().setActiveChatId).toHaveBeenCalledWith(null)\n  })\n\n  it('restores the message list when a retry stream fails on the active session', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-1',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-stream-1-cancelled',\n        message: 'Respuesta parcial',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n        isFrontendCancelled: true,\n      },\n    ]\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n    activeView.set('session-1')\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    replaceMessagesMock.mockClear()\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'retry-1',\n          placeholderId: 'answer-retry-1-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(replaceMessagesMock).toHaveBeenCalledWith(chatMessagesState.messages)\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n        detail: expect.objectContaining({ severity: 'error' }),\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('commits assistant attachments when an active stream finishes', async () => {\n    activeView.set('session-1')\n    useSessionsStore.setState({\n      messages: {\n        'session-1': [\n          {\n            id: streamingPlaceholderMessageId('live-attach'),\n            message: '',\n            role: ChatHistoryRole.ASSISTANT,\n            user: { id: 'assistant', name: 'MAIA' },\n            date: new Date(),\n          },\n        ],\n      },\n    })\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    const attachment = {\n      id: 'att-1',\n      name: 'brief.pdf',\n      type: 'pdf',\n      size: 10,\n      file: new File([], 'brief.pdf'),\n    }\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-attach',\n          placeholderId: streamingPlaceholderMessageId('live-attach'),\n        },\n        'Respuesta con adjunto',\n        [],\n        'memory-attach-1',\n        [attachment],\n        null,\n        null\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        id: 'answer-memory-attach-1',\n        attachments: expect.arrayContaining([expect.objectContaining({ id: 'att-1', name: 'brief.pdf' })]),\n      })\n    )\n  })\n\n  it('syncs task deletion on the project dashboard after approval', async () => {\n    const deleteExistingTaskFromDashboard = jest.fn()\n    window.newProjectDashboard = { deleteExistingTaskFromDashboard }\n    const originalPathname = window.location.pathname\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: '/projects/42/tasks' },\n    })\n\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-delete',\n        message: '¿Elimino la tarea?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'd1', tool_name: 'delete_task', tool_args: { task_id: 77 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project: { id: 42, name: 'Alpha' } as never }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'delete-live',\n          placeholderId: streamingPlaceholderMessageId('delete-live'),\n        },\n        'Tarea eliminada',\n        [],\n        'memory-delete-1'\n      )\n    })\n\n    expect(deleteExistingTaskFromDashboard).toHaveBeenCalledWith([77])\n\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: originalPathname },\n    })\n    delete window.newProjectDashboard\n  })\n\n  it('commits a pending approval message on the active session', () => {\n    activeView.set('session-1')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-hitl',\n          placeholderId: streamingPlaceholderMessageId('live-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-1',\n          original_thread_id: 'orig-1',\n          pending_actions: [{ thread_id: 't1', tool_name: 'edit_task', tool_args: { task_id: 1 }, tool_call_id: 'c1' }],\n          total_actions: 1,\n          metadata: {},\n        },\n        '¿Confirmás la edición?'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        approvalStatus: 'pending',\n        message: '¿Confirmás la edición?',\n      })\n    )\n  })\n\n  it('does not paint approval UI when the stream was auto-approved', () => {\n    activeView.set('session-1')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'auto-hitl',\n          placeholderId: streamingPlaceholderMessageId('auto-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-1',\n          original_thread_id: 'orig-auto',\n          pending_actions: [{ thread_id: 't-auto', tool_name: 'create_task', tool_args: {}, tool_call_id: 'c-auto' }],\n          total_actions: 1,\n          metadata: {},\n          auto_approved: true,\n        },\n        'Creando tarea'\n      )\n    })\n\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n\n  it('marks background sessions unread when approval is required off-screen', () => {\n    activeView.set('session-visible')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-visible',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-bg',\n          messageId: 'bg-hitl',\n          placeholderId: streamingPlaceholderMessageId('bg-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-bg',\n          original_thread_id: 'orig-bg',\n          pending_actions: [{ thread_id: 't-bg', tool_name: 'edit_task', tool_args: {}, tool_call_id: 'c-bg' }],\n          total_actions: 1,\n          metadata: {},\n        },\n        'Aprobación pendiente'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'approval_required')\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n\n  it('clears pinned context when switching to another existing chat', () => {\n    const setProject = jest.fn()\n    const setClient = jest.fn()\n    const setChipsProject = jest.fn()\n    const setTask = jest.fn()\n\n    const contextWrapper = ({ children }: { children: ReactNode }) => (\n      <GlobalContextTestProvider\n        value={{\n          agent: testAgent,\n          setProject,\n          setClient,\n          setChipsProject,\n          setTask,\n        }}\n      >\n        {children}\n      </GlobalContextTestProvider>\n    )\n\n    const { rerender } = renderHook(\n      ({ chatId }: { chatId: string | null }) =>\n        useChatManager({\n          chatId,\n          agents: [testAgent],\n        }),\n      {\n        wrapper: contextWrapper,\n        initialProps: { chatId: 'session-a' as string | null },\n      }\n    )\n\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(true)\n    rerender({ chatId: 'session-b' })\n\n    expect(setProject).toHaveBeenCalledWith(null)\n    expect(setClient).toHaveBeenCalledWith(null)\n    expect(setChipsProject).toHaveBeenCalledWith(null)\n    expect(setTask).toHaveBeenCalledWith(null)\n  })\n\n  it('commits partial assistant text when the stream stops mid-response', () => {\n    activeView.set('session-1')\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    const ctx: StreamContext = {\n      sessionId: 'session-1',\n      messageId: 'live-stop-1',\n      placeholderId: streamingPlaceholderMessageId('live-stop-1'),\n    }\n\n    act(() => {\n      streamCallbacks.onStreamUpdate?.(ctx, 'Parcial')\n    })\n\n    act(() => {\n      streamCallbacks.onStop?.('Parcial')\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({ message: 'Parcial', role: ChatHistoryRole.ASSISTANT })\n    )\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({ role: ChatHistoryRole.ASSISTANT, message: expect.stringMatching(/cancel/i) })\n    )\n  })\n\n  it('replays via orchestrator when retryCompletion reports turn_not_found', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-retry',\n        message: '¿Status?',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-abc',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-abc',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'turn_not_found' })\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(retryCompletionMock).toHaveBeenCalled()\n    expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({ message: '¿Status?' }))\n  })\n\n  it('shows a snackbar when retryCompletion hits the concurrent stream limit', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-limit',\n        message: 'Retry me',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-limit',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-limit',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'limit' })\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n        detail: expect.objectContaining({ message: expect.any(String) }),\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n\n  it('shows a snackbar when replayViaOrchestrator hits the concurrent stream limit', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-replay-limit',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-replay-limit',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-replay-limit',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'turn_not_found' })\n    askMaiaMock.mockResolvedValue({ started: false, reason: 'limit' })\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n\n  it('shows a snackbar when approval continue stream fails to start due to limit', async () => {\n    activeView.set('session-1')\n    startContinueStreamMock.mockResolvedValue({ started: false, reason: 'limit' })\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval-limit',\n        message: 'Approve?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-limit', tool_name: 'edit_task', tool_args: {} }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-limit'], 'approve')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n})\n"],"mappings":";;;;;AACA,SAASA,GAAG,EAAEC,UAAU,QAAQ,wBAAwB;AACxD,SAASC,yBAAyB,EAAEC,SAAS,QAAQ,2BAA2B;AAChF,SAASC,gBAAgB,QAAQ,uCAAuC;AACxE,SAASC,oBAAoB,QAAQ,2CAA2C;AAChF,SAA0BC,eAAe,QAAqB,kBAAkB;AAChF,SAASC,QAAQ,QAAQ,4DAA4D;AACrF,OAAOC,IAAI,MAAM,qBAAqB;AACtC,SAASC,UAAU,QAAQ,iCAAiC;AAC5D,SAASC,qBAAqB,QAAQ,0BAA0B;AAEhE,SAASC,kBAAkB,QAAQ,2BAA2B;AAC9D,SAASC,iCAAiC,QAAQ,2CAA2C;AAC7F,SAASC,gBAAgB,QAAQ,6CAA6C;AAC9E,SAASC,wBAAwB,QAAQ,mCAAmC;AAC5E,SAASC,6BAA6B,QAAQ,oCAAoC;AAClF,SAASC,cAAc,QAAQ,kBAAkB;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAEjD,IAAMC,oBAAoB,GAAGN,gBAAgE;AAE7F,IAAMO,yBAAyB,GAAGV,qBAA0E;AAkB5G,IAAIW,eAAwC,GAAG,CAAC,CAAC;AAEjD,IAAMC,uBAAuB,GAAGC,IAAI,CAACC,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAAC;EAAEC,OAAO,EAAE;AAAK,CAAC,CAAC;AAE9E,IAAMC,WAAW,GAAGJ,IAAI,CAACC,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAAC;EAAEC,OAAO,EAAE;AAAK,CAAC,CAAC;AAClE,IAAME,mBAAmB,GAAGL,IAAI,CAACC,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAAC;EAAEC,OAAO,EAAE;AAAK,CAAC,CAAC;AAC1E,IAAMG,iBAAiB,GAAGN,IAAI,CAACC,EAAE,CAAC,CAAC;AACnC,IAAMM,mBAAmB,GAAGP,IAAI,CAACC,EAAE,CAAC,CAAC;AACrC,IAAMO,cAAc,GAAGR,IAAI,CAACC,EAAE,CAAC,CAAC;AAChC,IAAMQ,SAAS,GAAGT,IAAI,CAACC,EAAE,CAAC,CAAC;AAE3B,IAAMS,iBAAiB,GAAG;EACxBC,eAAe,EAAE,KAAK;EACtBC,QAAQ,EAAE,EAAmB;EAC7BC,qBAAqB,EAAE,KAAK;EAC5BC,YAAY,EAAEd,IAAI,CAACC,EAAE,CAAC,CAAC;EACvBc,UAAU,EAAEP,cAAc;EAC1BQ,aAAa,EAAEhB,IAAI,CAACC,EAAE,CAAC,CAAC;EACxBgB,eAAe,EAAEV,mBAAmB;EACpCW,YAAY,EAAElB,IAAI,CAACC,EAAE,CAAC;AACxB,CAAC;AAEDD,IAAI,CAACmB,IAAI,CAAC,oBAAoB,EAAE;EAAA,OAAO;IACrCC,eAAe,EAAE,SAAjBA,eAAeA,CAAA;MAAA,OAAQV,iBAAiB;IAAA;EAC1C,CAAC;AAAA,CAAC,CAAC;AAEHV,IAAI,CAACmB,IAAI,CAAC,0BAA0B,EAAE;EAAA,OAAO;IAC3ChC,qBAAqB,EAAEa,IAAI,CAACC,EAAE,CAAC;EACjC,CAAC;AAAA,CAAC,CAAC;AAEHD,IAAI,CAACmB,IAAI,CAAC,gBAAgB,EAAE;EAAA,OAAO;IACjCE,WAAW,EAAE,SAAbA,WAAWA,CAAA;MAAA,OAAS;QAClBC,aAAa,EAAEtB,IAAI,CAACC,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAAC,EAAE;MAC/C,CAAC;IAAA;EACH,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACmB,IAAI,CAAC,sBAAsB,EAAE;EAAA,OAAO;IACvCI,iBAAiB,EAAE,SAAnBA,iBAAiBA,CAAA;MAAA,OAAS;QACxBC,iBAAiB,EAAExB,IAAI,CAACC,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAAC,QAAQ;MACzD,CAAC;IAAA;EACH,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACmB,IAAI,CAAC,aAAa,EAAE;EAAA,OAAO;IAC9BM,MAAM,EAAE;MAAEC,aAAa,EAAE;IAAmB,CAAC;IAC7CC,QAAQ,EAAE,SAAVA,QAAQA,CAAA;MAAA,OAAQlB,SAAS;IAAA;EAC3B,CAAC;AAAA,CAAC,CAAC;AAEHT,IAAI,CAACmB,IAAI,CAAC,wBAAwB,EAAE;EAAA,OAAO;IACzCS,OAAO,EAAE,SAATA,OAAOA,CAAA;MAAA,OAAS;QACdC,EAAE,EAAE,CAAC;QACLC,SAAS,EAAE,KAAK;QAChBC,QAAQ,EAAE,QAAQ;QAClBC,OAAO,EAAE,SAAS;QAClBC,IAAI,EAAE,IAAI;QACVC,UAAU,EAAE;MACd,CAAC;IAAA;EACH,CAAC;AAAA,CAAC,CAAC;AAEHlC,IAAI,CAACmB,IAAI,CAAC,2BAA2B,EAAE,YAAM;EAC3C,IAAMgB,KAAK,GAAG;IACZC,eAAe,EAAEpC,IAAI,CAACC,EAAE,CAAC,CAAC;IAC1BoC,cAAc,EAAErC,IAAI,CAACC,EAAE,CAAC,CAAC;IACzBqC,gBAAgB,EAAEtC,IAAI,CAACC,EAAE,CAAC,CAAC;IAC3BsC,iBAAiB,EAAE,IAAI;IACvBC,KAAK,EAAE,EAA0C;IACjDC,WAAW,EAAEzC,IAAI,CAACC,EAAE,CAAC;EACvB,CAAC;EACD,IAAMyC,aAAa,GAAG,SAAhBA,aAAaA,CAAIC,QAA0C;IAAA,OAAKA,QAAQ,CAACR,KAAK,CAAC;EAAA;EACrFS,MAAM,CAACC,MAAM,CAACH,aAAa,EAAE;IAAEI,QAAQ,EAAE,SAAVA,QAAQA,CAAA;MAAA,OAAQX,KAAK;IAAA;EAAC,CAAC,CAAC;EAEvD,OAAO;IACLO,aAAa,EAAbA,aAAa;IACbtD,kBAAkB,EAAE,SAApBA,kBAAkBA,CAAA;MAAA,OAAQ+C,KAAK;IAAA;EACjC,CAAC;AACH,CAAC,CAAC;AAEFnC,IAAI,CAACmB,IAAI,CAAC,qBAAqB,EAAE;EAAA,OAAO;IACtC4B,UAAU,EAAE,IAAI;IAChB,WAAS;MACPC,KAAK,EAAE;QACLC,cAAc,EAAEjD,IAAI,CAACC,EAAE,CAAC;MAC1B;IACF;EACF,CAAC;AAAA,CAAC,CAAC;AAEHD,IAAI,CAACmB,IAAI,CAAC,6CAA6C,EAAE;EAAA,OAAO;IAC9D7B,gBAAgB,EAAEU,IAAI,CAACC,EAAE,CAAC;EAC5B,CAAC;AAAA,CAAC,CAAC;AAEHD,IAAI,CAACmB,IAAI,CAAC,2CAA2C,EAAE;EAAA,OAAO;IAC5D9B,iCAAiC,EAAEW,IAAI,CAACC,EAAE,CAAC,CAAC;IAC5CiD,qCAAqC,EAAElD,IAAI,CAACC,EAAE,CAAC;EACjD,CAAC;AAAA,CAAC,CAAC;AAEHD,IAAI,CAACmB,IAAI,CAAC,2CAA2C,EAAE;EAAA,OAAO;IAC5DrC,oBAAoB,EAAE;MACpBqE,QAAQ,EAAEnD,IAAI,CAACC,EAAE,CAAC;QAAA,OAAM,KAAK;MAAA,EAAC;MAC9BmD,cAAc,EAAEpD,IAAI,CAACC,EAAE,CAAC;QAAA,OAAM,CAAC;MAAA,EAAC;MAChCoD,WAAW,EAAErD,IAAI,CAACC,EAAE,CAAC,CAAC;MACtBqD,mBAAmB,EAAE,SAArBA,mBAAmBA,CAAA;QAAA,OAA0BvD,uBAAuB,CAAAwD,KAAA,SAAAC,SAAQ,CAAC;MAAA;MAC7EC,UAAU,EAAEzD,IAAI,CAACC,EAAE,CAAC;IACtB,CAAC;IACDyD,sBAAsB,EAAE;EAC1B,CAAC;AAAA,CAAC,CAAC;AAEH,IAAMC,OAAO,GAAG,SAAVA,OAAOA,CAAAC,IAAA;EAAA,IAAMC,QAAQ,GAAAD,IAAA,CAARC,QAAQ;EAAA,oBACzBlE,IAAA,CAAChB,yBAAyB;IAACmF,KAAK,EAAE;MAAEC,KAAK,EAAEnF;IAAU,CAAE;IAAAiF,QAAA,EAAEA;EAAQ,CAA4B,CAAC;AAAA,CAC/F;AAEDG,QAAQ,CAAC,gBAAgB,EAAE,YAAM;EAC/BC,UAAU,CAAC,YAAM;IACfjE,IAAI,CAACkE,aAAa,CAAC,CAAC;IACpBpE,eAAe,GAAG,CAAC,CAAC;IACpBD,yBAAyB,CAACsE,kBAAkB,CAAC,UAAAC,OAAO,EAAI;MACtDtE,eAAe,GAAG;QAChBuE,OAAO,EAAED,OAAO,CAACC,OAAO;QACxBC,cAAc,EAAEF,OAAO,CAACE,cAAc;QACtCC,MAAM,EAAEH,OAAO,CAACG,MAAM;QACtBC,kBAAkB,EAAEJ,OAAO,CAACI,kBAAkB;QAC9CC,cAAc,EAAEL,OAAO,CAACK;MAC1B,CAAC;MACD,OAAO;QACLC,OAAO,EAAEtE,WAAW;QACpBuE,eAAe,EAAEtE,mBAAmB;QACpCuE,SAAS,EAAE,KAAK;QAChBC,SAAS,EAAE,KAAK;QAChBC,cAAc,EAAE,EAAE;QAClBC,cAAc,EAAE,IAAI;QACpBC,oBAAoB,EAAEhF,IAAI,CAACC,EAAE,CAAC,CAAC;QAC/BgF,aAAa,EAAE3E;MACjB,CAAC;IACH,CAAC,CAAC;IACFI,iBAAiB,CAACC,eAAe,GAAG,KAAK;IACzCD,iBAAiB,CAACE,QAAQ,GAAG,EAAE;IAC/B/B,gBAAgB,CAACqG,QAAQ,CAAC;MAAEC,IAAI,EAAE,CAAC,CAAC;MAAEvE,QAAQ,EAAE,CAAC,CAAC;MAAEwE,SAAS,EAAE,CAAC;IAAE,CAAC,CAAC;IACpElG,UAAU,CAACmG,GAAG,CAAC,IAAI,CAAC;IAClBvG,oBAAoB,CAACqE,QAAQ,CAAemC,eAAe,CAAC,KAAK,CAAC;IAClExG,oBAAoB,CAACsE,cAAc,CAAekC,eAAe,CAAC,CAAC,CAAC;IACtEvF,uBAAuB,CAACG,iBAAiB,CAAC;MAAEC,OAAO,EAAE;IAAK,CAAC,CAAC;IAC5DC,WAAW,CAACF,iBAAiB,CAAC;MAAEC,OAAO,EAAE;IAAK,CAAC,CAAC;IAChDE,mBAAmB,CAACH,iBAAiB,CAAC;MAAEC,OAAO,EAAE;IAAK,CAAC,CAAC;EAC1D,CAAC,CAAC;EAEFoF,EAAE,CAAC,6CAA6C,EAAE,YAAM;IACtD,IAAAC,WAAA,GAAmB9G,UAAU,CAC3B;QAAA,OACEe,cAAc,CAAC;UACbgG,MAAM,EAAE,WAAW;UACnBC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QAAE+E,OAAO,EAAPA;MAAQ,CACZ,CAAC;MAPOgC,MAAM,GAAAH,WAAA,CAANG,MAAM;IASdC,MAAM,CAACD,MAAM,CAACE,OAAO,CAACjF,QAAQ,CAAC,CAACkF,OAAO,CAAC,EAAE,CAAC;IAC3CF,MAAM,CAACD,MAAM,CAACE,OAAO,CAACE,UAAU,CAAC,CAACC,IAAI,CAAC,KAAK,CAAC;EAC/C,CAAC,CAAC;EAEFT,EAAE,CAAC,2DAA2D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAC,SAAA;IAAA,IAAAC,YAAA,EAAAV,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAC,SAAA;MAAA,kBAAAA,SAAA,CAAAC,IAAA,GAAAD,SAAA,CAAAE,IAAA;QAAA;UAAAJ,YAAA,GAC3C3H,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAU,YAAA,CAANV,MAAM;UAAAY,SAAA,CAAAE,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAO,QAAA;YAAA,OAAAR,mBAAA,CAAAI,IAAA,WAAAK,QAAA;cAAA,kBAAAA,QAAA,CAAAH,IAAA,GAAAG,QAAA,CAAAF,IAAA;gBAAA;kBAAAE,QAAA,CAAAF,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,WAAW,CAAC;gBAAA;gBAAA;kBAAA,OAAAD,QAAA,CAAAE,IAAA;cAAA;YAAA,GAAAH,OAAA;UAAA,CAC9C,GAAC;QAAA;UAEFd,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBC,OAAO,EAAE,WAAW;YACpBvB,MAAM,EAAE,WAAW;YACnBwB,OAAO,EAAErI,SAAS,CAACiD,EAAE;YACrBqF,SAAS,EAAEtI,SAAS,CAACuI;UACvB,CAAC,CACH,CAAC;UACDvB,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBC,OAAO,EAAE,WAAW;YACpBI,IAAI,EAAE;UACR,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAb,SAAA,CAAAM,IAAA;MAAA;IAAA,GAAAT,QAAA;EAAA,CACF,GAAC;EAEFb,EAAE,CAAC,2DAA2D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAkB,SAAA;IAAA,IAAAC,WAAA,EAAAC,YAAA,EAAA5B,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAkB,SAAA;MAAA,kBAAAA,SAAA,CAAAhB,IAAA,GAAAgB,SAAA,CAAAf,IAAA;QAAA;UAC9D;UAAE3H,oBAAoB,CAACsE,cAAc,CAAekC,eAAe,CAAC,CAAC,CAAC;UAChEgC,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UAAAH,YAAA,GAEtC7I,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA4B,YAAA,CAAN5B,MAAM;UAAA6B,SAAA,CAAAf,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAwB,SAAA;YAAA,OAAAzB,mBAAA,CAAAI,IAAA,WAAAsB,SAAA;cAAA,kBAAAA,SAAA,CAAApB,IAAA,GAAAoB,SAAA,CAAAnB,IAAA;gBAAA;kBAAAmB,SAAA,CAAAnB,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,MAAM,CAAC;gBAAA;gBAAA;kBAAA,OAAAgB,SAAA,CAAAf,IAAA;cAAA;YAAA,GAAAc,QAAA;UAAA,CACzC,GAAC;QAAA;UAEF/B,MAAM,CAACxF,WAAW,CAAC,CAACyH,GAAG,CAACC,gBAAgB,CAAC,CAAC;UAC1ClC,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE;UACR,CAAC,CACH,CAAC;UAEDT,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAR,SAAA,CAAAX,IAAA;MAAA;IAAA,GAAAQ,QAAA;EAAA,CAC1B,GAAC;EAEF9B,EAAE,CAAC,wCAAwC,EAAE,YAAM;IACjD,IAAA0C,YAAA,GAAmBvJ,UAAU,CAC3B;QAAA,OACEe,cAAc,CAAC;UACbgG,MAAM,EAAE,WAAW;UACnBC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QAAE+E,OAAO,EAAPA;MAAQ,CACZ,CAAC;MAPOgC,MAAM,GAAAsC,YAAA,CAANtC,MAAM;IASdlH,GAAG,CAAC,YAAM;MACRkH,MAAM,CAACE,OAAO,CAACqC,cAAc,CAAC,CAAC;IACjC,CAAC,CAAC;IAEFtC,MAAM,CAACtF,iBAAiB,CAAC,CAACwH,gBAAgB,CAAC,CAAC;EAC9C,CAAC,CAAC;EAEFvC,EAAE,CAAC,4DAA4D,EAAE,YAAM;IACrE,IAAA4C,YAAA,GAAmBzJ,UAAU,CAC3B;QAAA,OACEe,cAAc,CAAC;UACbgG,MAAM,EAAE,WAAW;UACnBC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QAAE+E,OAAO,EAAPA;MAAQ,CACZ,CAAC;MAPOgC,MAAM,GAAAwC,YAAA,CAANxC,MAAM;IASdlH,GAAG,CAAC,YAAM;MACRkH,MAAM,CAACE,OAAO,CAACuC,SAAS,CAAC,CAAC;IAC5B,CAAC,CAAC;IAEFxC,MAAM,CAACD,MAAM,CAACE,OAAO,CAACwC,aAAa,CAAC,CAACR,GAAG,CAAC7B,IAAI,CAAC,WAAW,CAAC;EAC5D,CAAC,CAAC;EAEFT,EAAE,CAAC,0CAA0C,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAmC,SAAA;IAAA,IAAAC,YAAA,EAAA5C,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAkC,SAAA;MAAA,kBAAAA,SAAA,CAAAhC,IAAA,GAAAgC,SAAA,CAAA/B,IAAA;QAAA;UAC7C/F,iBAAiB,CAACC,eAAe,GAAG,IAAI;UAAA4H,YAAA,GAErB7J,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA4C,YAAA,CAAN5C,MAAM;UASdC,MAAM,CAACD,MAAM,CAACE,OAAO,CAACE,UAAU,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;UAAAwC,SAAA,CAAA/B,IAAA;UAAA,OAEtChI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAsC,SAAA;YAAA,OAAAvC,mBAAA,CAAAI,IAAA,WAAAoC,SAAA;cAAA,kBAAAA,SAAA,CAAAlC,IAAA,GAAAkC,SAAA,CAAAjC,IAAA;gBAAA;kBAAAiC,SAAA,CAAAjC,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,MAAM,CAAC;gBAAA;gBAAA;kBAAA,OAAA8B,SAAA,CAAA7B,IAAA;cAAA;YAAA,GAAA4B,QAAA;UAAA,CACzC,GAAC;QAAA;UAEF7C,MAAM,CAACxF,WAAW,CAAC,CAACyH,GAAG,CAACC,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAU,SAAA,CAAA3B,IAAA;MAAA;IAAA,GAAAyB,QAAA;EAAA,CAC3C,GAAC;EAEF/C,EAAE,CAAC,0DAA0D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAwC,SAAA;IAAA,IAAAC,YAAA,EAAAjD,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAuC,SAAA;MAAA,kBAAAA,SAAA,CAAArC,IAAA,GAAAqC,SAAA,CAAApC,IAAA;QAAA;UAAAmC,YAAA,GAC1ClK,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAiD,YAAA,CAANjD,MAAM;UAAAkD,SAAA,CAAApC,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA2C,SAAA;YAAA,OAAA5C,mBAAA,CAAAI,IAAA,WAAAyC,SAAA;cAAA,kBAAAA,SAAA,CAAAvC,IAAA,GAAAuC,SAAA,CAAAtC,IAAA;gBAAA;kBAAAsC,SAAA,CAAAtC,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,MAAM,EAAE;oBACvCoC,QAAQ,EAAE,CAAC;sBAAEnH,EAAE,EAAE,IAAI;sBAAEkG,IAAI,EAAE,MAAM;sBAAEkB,KAAK,EAAE;oBAAM,CAAC;kBACrD,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAF,SAAA,CAAAlC,IAAA;cAAA;YAAA,GAAAiC,QAAA;UAAA,CACH,GAAC;QAAA;UAEFlD,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBmC,cAAc,EAAEtD,MAAM,CAACmB,gBAAgB,CAAC;cACtCoC,IAAI,EAAEvD,MAAM,CAACwD,eAAe,CAAC,CAACxD,MAAM,CAACmB,gBAAgB,CAAC;gBAAElF,EAAE,EAAE,IAAI;gBAAEsF,IAAI,EAAE;cAAM,CAAC,CAAC,CAAC;YACnF,CAAC;UACH,CAAC,CACH,CAAC;UACDvB,MAAM,CAACnF,SAAS,CAAC,CAACqG,oBAAoB,CAAC,kBAAkB,CAAC;QAAA;QAAA;UAAA,OAAA+B,SAAA,CAAAhC,IAAA;MAAA;IAAA,GAAA8B,QAAA;EAAA,CAC3D,GAAC;EAEFpD,EAAE,CAAC,oDAAoD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAkD,SAAA;IAAA,IAAAC,YAAA,EAAA3D,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAiD,SAAA;MAAA,kBAAAA,SAAA,CAAA/C,IAAA,GAAA+C,SAAA,CAAA9C,IAAA;QAAA;UACvD/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,YAAY;YAChBmF,OAAO,EAAE,MAAM;YACfI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,2BAA2B;YAC/BmF,OAAO,EAAE,mBAAmB;YAC5BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAY,CAAC;YAC5CsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBE,mBAAmB,EAAE;UACvB,CAAC,CACF;UAAAN,YAAA,GAEkB5K,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA2D,YAAA,CAAN3D,MAAM;UAAA4D,SAAA,CAAA9C,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA0D,SAAA;YAAA,OAAA3D,mBAAA,CAAAI,IAAA,WAAAwD,SAAA;cAAA,kBAAAA,SAAA,CAAAtD,IAAA,GAAAsD,SAAA,CAAArD,IAAA;gBAAA;kBAAAqD,SAAA,CAAArD,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAkJ,SAAA,CAAAjD,IAAA;cAAA;YAAA,GAAAgD,QAAA;UAAA,CACjE,GAAC;QAAA;UAEFjE,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBC,OAAO,EAAE,MAAM;YACfvB,MAAM,EAAE;UACV,CAAC,CACH,CAAC;UACDG,MAAM,CAACrF,mBAAmB,CAAC,CAACuH,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAyB,SAAA,CAAA1C,IAAA;MAAA;IAAA,GAAAwC,QAAA;EAAA,CAC/C,GAAC;EAEF9D,EAAE,CAAC,6DAA6D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA6D,UAAA;IAAA,IAAAC,UAAA,EAAAC,OAAA,EAAAC,YAAA,EAAAxE,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA8D,UAAA;MAAA,kBAAAA,UAAA,CAAA5D,IAAA,GAAA4D,UAAA,CAAA3D,IAAA;QAAA;UAC1DwD,UAAU,GAAGjK,IAAI,CAACC,EAAE,CAAC,CAAC;UACtBiK,OAAO,GAAG;YAAErI,EAAE,EAAE,EAAE;YAAEsF,IAAI,EAAE;UAAa,CAAC;UAAAgD,YAAA,GAE3BzL,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YACE+E,OAAO,EAAE,SAATA,OAAOA,CAAA0G,MAAA;cAAA,IAAKxG,QAAQ,GAAAwG,MAAA,CAARxG,QAAQ;cAAA,oBAClBlE,IAAA,CAAChB,yBAAyB;gBAACmF,KAAK,EAAE;kBAAEC,KAAK,EAAEnF,SAAS;kBAAEsL,OAAO,EAAPA,OAAO;kBAAED,UAAU,EAAVA;gBAAW,CAAE;gBAAApG,QAAA,EACzEA;cAAQ,CACgB,CAAC;YAAA;UAEhC,CACF,CAAC,EAbO8B,MAAM,GAAAwE,YAAA,CAANxE,MAAM;UAAAyE,UAAA,CAAA3D,IAAA;UAAA,OAeRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAmE,SAAA;YAAA,OAAApE,mBAAA,CAAAI,IAAA,WAAAiE,SAAA;cAAA,kBAAAA,SAAA,CAAA/D,IAAA,GAAA+D,SAAA,CAAA9D,IAAA;gBAAA;kBAAA8D,SAAA,CAAA9D,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,qBAAqB,CAAC;gBAAA;gBAAA;kBAAA,OAAA2D,SAAA,CAAA1D,IAAA;cAAA;YAAA,GAAAyD,QAAA;UAAA,CACxD,GAAC;QAAA;UAEFlK,WAAW,CAACoK,SAAS,CAAC,CAAC;UAEvB/L,GAAG,CAAC,YAAM;YACRkH,MAAM,CAACE,OAAO,CAAC4E,aAAa,CAAC;cAAE5I,EAAE,EAAE,EAAE;cAAEsF,IAAI,EAAE,YAAY;cAAEuD,KAAK,EAAE,CAAC;cAAEC,QAAQ,EAAE;YAAE,CAAU,CAAC;UAC9F,CAAC,CAAC;UAEF/E,MAAM,CAACqE,UAAU,CAAC,CAACnD,oBAAoB,CAAClB,MAAM,CAACmB,gBAAgB,CAAC;YAAElF,EAAE,EAAE;UAAG,CAAC,CAAC,CAAC;UAC5E+D,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBC,OAAO,EAAE,qBAAqB;YAC9B4D,SAAS,EAAE,EAAE;YACbF,KAAK,EAAE,CAAC;YACRC,QAAQ,EAAE;UACZ,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAP,UAAA,CAAAvD,IAAA;MAAA;IAAA,GAAAmD,SAAA;EAAA,CACF,GAAC;EAEFzE,EAAE,CAAC,gEAAgE,EAAE,YAAM;IACzE,IAAAsF,YAAA,GAAmBnM,UAAU,CAC3B;QAAA,OACEe,cAAc,CAAC;UACbgG,MAAM,EAAE,WAAW;UACnBC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QAAE+E,OAAO,EAAPA;MAAQ,CACZ,CAAC;MAPOgC,MAAM,GAAAkF,YAAA,CAANlF,MAAM;IASdlH,GAAG,CAAC,YAAM;MACRkH,MAAM,CAACE,OAAO,CAAC4E,aAAa,CAAC;QAAE5I,EAAE,EAAE,EAAE;QAAEsF,IAAI,EAAE;MAAa,CAAU,CAAC;IACvE,CAAC,CAAC;IAEFvB,MAAM,CAACxF,WAAW,CAAC,CAACyH,GAAG,CAACC,gBAAgB,CAAC,CAAC;EAC5C,CAAC,CAAC;EAEFvC,EAAE,CAAC,uDAAuD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA2E,UAAA;IAAA,IAAAC,YAAA,EAAApF,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA0E,UAAA;MAAA,kBAAAA,UAAA,CAAAxE,IAAA,GAAAwE,UAAA,CAAAvE,IAAA;QAAA;UAC1DvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,cAAc;YAClBmF,OAAO,EAAE,oBAAoB;YAC7BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBuB,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,UAAU;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YACjG;UACF,CAAC,CACF;UAAAR,YAAA,GAEkBrM,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAoF,YAAA,CAANpF,MAAM;UAAAqF,UAAA,CAAAvE,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAqF,UAAA;YAAA,OAAAtF,mBAAA,CAAAI,IAAA,WAAAmF,UAAA;cAAA,kBAAAA,UAAA,CAAAjF,IAAA,GAAAiF,UAAA,CAAAhF,IAAA;gBAAA;kBAAAgF,UAAA,CAAAhF,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC;gBAAA;gBAAA;kBAAA,OAAAD,UAAA,CAAA5E,IAAA;cAAA;YAAA,GAAA2E,SAAA;UAAA,CACpE,GAAC;QAAA;UAEF5F,MAAM,CAAC7F,uBAAuB,CAAC,CAAC+G,oBAAoB,CAClDlB,MAAM,CAACmB,gBAAgB,CAAC;YACtB4E,eAAe,EAAE/F,MAAM,CAACmB,gBAAgB,CAAC;cACvC6E,QAAQ,EAAE;YACZ,CAAC;UACH,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAZ,UAAA,CAAAnE,IAAA;MAAA;IAAA,GAAAiE,SAAA;EAAA,CACF,GAAC;EAEFvF,EAAE,CAAC,uDAAuD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA0F,UAAA;IAAA,IAAAC,aAAA,EAAAnG,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAyF,UAAA;MAAA,kBAAAA,UAAA,CAAAvF,IAAA,GAAAuF,UAAA,CAAAtF,IAAA;QAAA;UAC1DvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,cAAc;YAClBmF,OAAO,EAAE,oBAAoB;YAC7BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBuB,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,UAAU;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YACjG;UACF,CAAC,CACF;UAAAO,aAAA,GAEkBpN,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAmG,aAAA,CAANnG,MAAM;UAAAoG,UAAA,CAAAtF,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA6F,UAAA;YAAA,OAAA9F,mBAAA,CAAAI,IAAA,WAAA2F,UAAA;cAAA,kBAAAA,UAAA,CAAAzF,IAAA,GAAAyF,UAAA,CAAAxF,IAAA;gBAAA;kBAAAwF,UAAA,CAAAxF,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC;gBAAA;gBAAA;kBAAA,OAAAO,UAAA,CAAApF,IAAA;cAAA;YAAA,GAAAmF,SAAA;UAAA,CACrE,GAAC;QAAA;UAEFpG,MAAM,CAAC7F,uBAAuB,CAAC,CAAC+G,oBAAoB,CAClDlB,MAAM,CAACmB,gBAAgB,CAAC;YACtBmF,SAAS,EAAE,WAAW;YACtBP,eAAe,EAAE/F,MAAM,CAACmB,gBAAgB,CAAC;cACvCoF,SAAS,EAAE,CAAC,UAAU,CAAC;cACvBP,QAAQ,EAAE;YACZ,CAAC;UACH,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAG,UAAA,CAAAlF,IAAA;MAAA;IAAA,GAAAgF,SAAA;EAAA,CACF,GAAC;EAEFtG,EAAE,CAAC,iDAAiD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAiG,UAAA;IAAA,IAAAC,aAAA,EAAA1G,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAgG,UAAA;MAAA,kBAAAA,UAAA,CAAA9F,IAAA,GAAA8F,UAAA,CAAA7F,IAAA;QAAA;UACpD/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,UAAU;YACdmF,OAAO,EAAE,WAAW;YACpBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAY,CAAC;YAC5CsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,CACF;UAED1J,IAAI,CAACuM,MAAM,CAACtN,IAAI,CAAC+D,KAAK,CAACC,cAAc,CAAC,CAAC/C,iBAAiB,CAAC,IAAI,CAAC;UAAAmM,aAAA,GAE3C3N,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA0G,aAAA,CAAN1G,MAAM;UAAA2G,UAAA,CAAA7F,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAqG,UAAA;YAAA,OAAAtG,mBAAA,CAAAI,IAAA,WAAAmG,UAAA;cAAA,kBAAAA,UAAA,CAAAjG,IAAA,GAAAiG,UAAA,CAAAhG,IAAA;gBAAA;kBAAAgG,UAAA,CAAAhG,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6G,cAAc,CAAC1N,QAAQ,CAAC2N,SAAS,EAAE,UAAU,CAAC;gBAAA;gBAAA;kBAAA,OAAAF,UAAA,CAAA5F,IAAA;cAAA;YAAA,GAAA2F,SAAA;UAAA,CACpE,GAAC;QAAA;UAEF5G,MAAM,CAAC3G,IAAI,CAAC+D,KAAK,CAACC,cAAc,CAAC,CAAC6D,oBAAoB,CAAC,UAAU,EAAE,IAAI,CAAC;QAAA;QAAA;UAAA,OAAAwF,UAAA,CAAAzF,IAAA;MAAA;IAAA,GAAAuF,SAAA;EAAA,CACzE,GAAC;EAEF7G,EAAE,CAAC,wDAAwD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAyG,UAAA;IAAA,IAAAC,aAAA,EAAAlH,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAwG,UAAA;MAAA,kBAAAA,UAAA,CAAAtG,IAAA,GAAAsG,UAAA,CAAArG,IAAA;QAAA;UAC3D/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,UAAU;YACdmF,OAAO,EAAE,WAAW;YACpBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAY,CAAC;YAC5CsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,CACF;UAED1J,IAAI,CAACuM,MAAM,CAACtN,IAAI,CAAC+D,KAAK,CAACC,cAAc,CAAC,CAAC/C,iBAAiB,CAAC,KAAK,CAAC;UAAA2M,aAAA,GAE5CnO,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAkH,aAAA,CAANlH,MAAM;UAAAmH,UAAA,CAAArG,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA4G,UAAA;YAAA,OAAA7G,mBAAA,CAAAI,IAAA,WAAA0G,UAAA;cAAA,kBAAAA,UAAA,CAAAxG,IAAA,GAAAwG,UAAA,CAAAvG,IAAA;gBAAA;kBAAAuG,UAAA,CAAAvG,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6G,cAAc,CAAC1N,QAAQ,CAACiO,WAAW,EAAE,UAAU,CAAC;gBAAA;gBAAA;kBAAA,OAAAD,UAAA,CAAAnG,IAAA;cAAA;YAAA,GAAAkG,SAAA;UAAA,CACtE,GAAC;QAAA;UAEFnH,MAAM,CAAClF,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAACiH,GAAG,CAACqF,cAAc,CAAC,YAAY,CAAC;QAAA;QAAA;UAAA,OAAAJ,UAAA,CAAAjG,IAAA;MAAA;IAAA,GAAA+F,SAAA;EAAA,CACvE,GAAC;EAEFrH,EAAE,CAAC,oDAAoD,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAgH,UAAA;IAAA,IAAAC,UAAA,EAAAC,aAAA,EAAA1H,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAgH,UAAA;MAAA,kBAAAA,UAAA,CAAA9G,IAAA,GAAA8G,UAAA,CAAA7G,IAAA;QAAA;UACjD2G,UAAU,GAAGpN,IAAI,CAACyH,KAAK,CAAC8F,OAAO,EAAE,OAAO,CAAC,CAACpJ,kBAAkB,CAAC;YAAA,OAAMqJ,SAAS;UAAA,EAAC;UAAAH,aAAA,GAEhE3O,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA0H,aAAA,CAAN1H,MAAM;UAAA2H,UAAA,CAAA7G,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAsH,UAAA;YAAA,OAAAvH,mBAAA,CAAAI,IAAA,WAAAoH,UAAA;cAAA,kBAAAA,UAAA,CAAAlH,IAAA,GAAAkH,UAAA,CAAAjH,IAAA;gBAAA;kBAAAiH,UAAA,CAAAjH,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,EAAE,EAAE,SAAS,CAAC;gBAAA;gBAAA;kBAAA,OAAAgC,UAAA,CAAA7G,IAAA;cAAA;YAAA,GAAA4G,SAAA;UAAA,CAC3D,GAAC;QAAA;UAEF7H,MAAM,CAAC7F,uBAAuB,CAAC,CAAC8H,GAAG,CAACC,gBAAgB,CAAC,CAAC;UACtDlC,MAAM,CAACwH,UAAU,CAAC,CAACtF,gBAAgB,CAAC,CAAC;UAErCsF,UAAU,CAACpF,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAsF,UAAA,CAAAzG,IAAA;MAAA;IAAA,GAAAsG,SAAA;EAAA,CACzB,GAAC;EAEF5H,EAAE,CAAC,8CAA8C,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAwH,UAAA;IAAA,IAAAC,UAAA,EAAAC,aAAA,EAAAlI,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAwH,UAAA;MAAA,kBAAAA,UAAA,CAAAtH,IAAA,GAAAsH,UAAA,CAAArH,IAAA;QAAA;UAC3CmH,UAAU,GAAG;YAAE/L,EAAE,EAAE,IAAI;YAAEsF,IAAI,EAAE,SAAS;YAAEY,IAAI,EAAE,KAAK;YAAEgG,IAAI,EAAE,CAAC;YAAEC,IAAI,EAAE,IAAIC,IAAI,CAAC,EAAE,EAAE,SAAS;UAAE,CAAC;UAAAJ,aAAA,GAElFnP,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAkI,aAAA,CAANlI,MAAM;UAAAmI,UAAA,CAAArH,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA+H,UAAA;YAAA,OAAAhI,mBAAA,CAAAI,IAAA,WAAA6H,UAAA;cAAA,kBAAAA,UAAA,CAAA3H,IAAA,GAAA2H,UAAA,CAAA1H,IAAA;gBAAA;kBAAA0H,UAAA,CAAA1H,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACe,WAAW,CAAC,aAAa,EAAE,CAACgH,UAAU,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAO,UAAA,CAAAtH,IAAA;cAAA;YAAA,GAAAqH,SAAA;UAAA,CAC9D,GAAC;QAAA;UAEFtI,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBC,OAAO,EAAE,aAAa;YACtBoH,WAAW,EAAE,CAACR,UAAU;UAC1B,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAE,UAAA,CAAAjH,IAAA;MAAA;IAAA,GAAA8G,SAAA;EAAA,CACF,GAAC;EAEFpI,EAAE,CAAC,kEAAkE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAkI,UAAA;IAAA,IAAAC,aAAA,EAAA3I,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAiI,UAAA;MAAA,kBAAAA,UAAA,CAAA/H,IAAA,GAAA+H,UAAA,CAAA9H,IAAA;QAAA;UACrE/F,iBAAiB,CAACI,YAAY,CAACZ,iBAAiB,CAACsN,SAAS,CAAC;UAAAc,aAAA,GAExC5P,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA2I,aAAA,CAAN3I,MAAM;UAAA4I,UAAA,CAAA9H,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAqI,UAAA;YAAA,OAAAtI,mBAAA,CAAAI,IAAA,WAAAmI,UAAA;cAAA,kBAAAA,UAAA,CAAAjI,IAAA,GAAAiI,UAAA,CAAAhI,IAAA;gBAAA;kBAAAgI,UAAA,CAAAhI,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6I,cAAc,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAD,UAAA,CAAA5H,IAAA;cAAA;YAAA,GAAA2H,SAAA;UAAA,CACtC,GAAC;QAAA;UAEF5I,MAAM,CAAClF,iBAAiB,CAACI,YAAY,CAAC,CAACgH,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAyG,UAAA,CAAA1H,IAAA;MAAA;IAAA,GAAAwH,SAAA;EAAA,CAC1D,GAAC;EAEF9I,EAAE,CAAC,oEAAoE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAwI,UAAA;IAAA,IAAAC,aAAA,EAAAjJ,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAuI,UAAA;MAAA,kBAAAA,UAAA,CAAArI,IAAA,GAAAqI,UAAA,CAAApI,IAAA;QAAA;UAAAmI,aAAA,GACpDlQ,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbqP,kBAAkB,EAAE;gBAAE9H,OAAO,EAAE,EAAE;gBAAEoH,WAAW,EAAE,EAAE;gBAAEW,KAAK,EAAE;cAAmB,CAAC;cAC/ErJ,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAiJ,aAAA,CAANjJ,MAAM;UAAAkJ,UAAA,CAAApI,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA6I,UAAA;YAAA,OAAA9I,mBAAA,CAAAI,IAAA,WAAA2I,UAAA;cAAA,kBAAAA,UAAA,CAAAzI,IAAA,GAAAyI,UAAA,CAAAxI,IAAA;gBAAA;kBAAAwI,UAAA,CAAAxI,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6I,cAAc,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAO,UAAA,CAAApI,IAAA;cAAA;YAAA,GAAAmI,SAAA;UAAA,CACtC,GAAC;QAAA;UAEFpJ,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CAAClB,MAAM,CAACmB,gBAAgB,CAAC;YAAEgI,KAAK,EAAE;UAAmB,CAAC,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAF,UAAA,CAAAhI,IAAA;MAAA;IAAA,GAAA8H,SAAA;EAAA,CACjG,GAAC;EAEFpJ,EAAE,CAAC,kEAAkE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA+I,UAAA;IAAA,IAAAC,aAAA,EAAAxJ,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA8I,UAAA;MAAA,kBAAAA,UAAA,CAAA5I,IAAA,GAAA4I,UAAA,CAAA3I,IAAA;QAAA;UAAA0I,aAAA,GAClDzQ,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbqP,kBAAkB,EAAE;gBAAE9H,OAAO,EAAE,KAAK;gBAAEoH,WAAW,EAAE;cAAG,CAAC;cACvD1I,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAwJ,aAAA,CAANxJ,MAAM;UAAAyJ,UAAA,CAAA3I,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAkJ,UAAA;YAAA,OAAAnJ,mBAAA,CAAAI,IAAA,WAAAgJ,UAAA;cAAA,kBAAAA,UAAA,CAAA9I,IAAA,GAAA8I,UAAA,CAAA7I,IAAA;gBAAA;kBAAA6I,UAAA,CAAA7I,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6I,cAAc,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAY,UAAA,CAAAzI,IAAA;cAAA;YAAA,GAAAwI,SAAA;UAAA,CACtC,GAAC;QAAA;UAEFzJ,MAAM,CAACxF,WAAW,CAAC,CAACyH,GAAG,CAACC,gBAAgB,CAAC,CAAC;UAC1ClC,MAAM,CAAClF,iBAAiB,CAACI,YAAY,CAAC,CAAC+G,GAAG,CAACC,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAsH,UAAA,CAAAvI,IAAA;MAAA;IAAA,GAAAqI,SAAA;EAAA,CAC9D,GAAC;EAEF3J,EAAE,CAAC,4DAA4D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAoJ,UAAA;IAAA,IAAAjI,WAAA,EAAAkI,aAAA,EAAA7J,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAmJ,UAAA;MAAA,kBAAAA,UAAA,CAAAjJ,IAAA,GAAAiJ,UAAA,CAAAhJ,IAAA;QAAA;UAC/D;UAAE3H,oBAAoB,CAACsE,cAAc,CAAekC,eAAe,CAAC,CAAC,CAAC;UAChEgC,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UAEzDhH,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,YAAY;YAChBmF,OAAO,EAAE,MAAM;YACfI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,2BAA2B;YAC/BmF,OAAO,EAAE,mBAAmB;YAC5BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAY,CAAC;YAC5CsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBE,mBAAmB,EAAE;UACvB,CAAC,CACF;UAAA4F,aAAA,GAEkB9Q,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA6J,aAAA,CAAN7J,MAAM;UAAA8J,UAAA,CAAAhJ,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAuJ,UAAA;YAAA,OAAAxJ,mBAAA,CAAAI,IAAA,WAAAqJ,UAAA;cAAA,kBAAAA,UAAA,CAAAnJ,IAAA,GAAAmJ,UAAA,CAAAlJ,IAAA;gBAAA;kBAAAkJ,UAAA,CAAAlJ,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAA+O,UAAA,CAAA9I,IAAA;cAAA;YAAA,GAAA6I,SAAA;UAAA,CACjE,GAAC;QAAA;UAEF9J,MAAM,CAACxF,WAAW,CAAC,CAACyH,GAAG,CAACC,gBAAgB,CAAC,CAAC;UAC1ClC,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE;UACR,CAAC,CACH,CAAC;UAEDT,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAyH,UAAA,CAAA5I,IAAA;MAAA;IAAA,GAAA0I,SAAA;EAAA,CAC1B,GAAC;EAEFhK,EAAE,CAAC,uEAAuE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAyJ,UAAA;IAAA,IAAAC,aAAA,EAAAlK,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAwJ,UAAA;MAAA,kBAAAA,UAAA,CAAAtJ,IAAA,GAAAsJ,UAAA,CAAArJ,IAAA;QAAA;UAC1EvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UACzBvG,oBAAoB,CAACqE,QAAQ,CAAemC,eAAe,CAAC,IAAI,CAAC;UACnE5E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,cAAc;YAClBmF,OAAO,EAAE,UAAU;YACnBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBuB,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,UAAU;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE,CAAC;cAAE,CAAC;YACpF;UACF,CAAC,CACF;UAAAuE,aAAA,GAEkBnR,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAkK,aAAA,CAANlK,MAAM;UAAAmK,UAAA,CAAArJ,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA4J,UAAA;YAAA,OAAA7J,mBAAA,CAAAI,IAAA,WAAA0J,UAAA;cAAA,kBAAAA,UAAA,CAAAxJ,IAAA,GAAAwJ,UAAA,CAAAvJ,IAAA;gBAAA;kBAAAuJ,UAAA,CAAAvJ,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC;gBAAA;gBAAA;kBAAA,OAAAsE,UAAA,CAAAnJ,IAAA;cAAA;YAAA,GAAAkJ,SAAA;UAAA,CACrE,GAAC;QAAA;UAEFnK,MAAM,CAAC7F,uBAAuB,CAAC,CAAC8H,GAAG,CAACC,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAgI,UAAA,CAAAjJ,IAAA;MAAA;IAAA,GAAA+I,SAAA;EAAA,CACvD,GAAC;EAEFrK,EAAE,CAAC,sEAAsE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA8J,UAAA;IAAA,IAAAC,aAAA,EAAAC,aAAA,EAAAxK,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA8J,UAAA;MAAA,kBAAAA,UAAA,CAAA5J,IAAA,GAAA4J,UAAA,CAAA3J,IAAA;QAAA;UACzEvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,cAAc;YAClBmF,OAAO,EAAE,oBAAoB;YAC7BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBuB,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,UAAU;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YACjG;UACF,CAAC,CACF;UAEK2E,aAAa,GAAG,CAAC;YAAE7E,SAAS,EAAE,WAAW;YAAEgF,IAAI,EAAE;cAAE9E,OAAO,EAAE;YAAG;UAAE,CAAC,CAAC;UAAA4E,aAAA,GACtDzR,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAwK,aAAA,CAANxK,MAAM;UAAAyK,UAAA,CAAA3J,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAmK,UAAA;YAAA,OAAApK,mBAAA,CAAAI,IAAA,WAAAiK,UAAA;cAAA,kBAAAA,UAAA,CAAA/J,IAAA,GAAA+J,UAAA,CAAA9J,IAAA;gBAAA;kBAAA8J,UAAA,CAAA9J,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAEwE,aAAa,CAAC;gBAAA;gBAAA;kBAAA,OAAAK,UAAA,CAAA1J,IAAA;cAAA;YAAA,GAAAyJ,SAAA;UAAA,CACnF,GAAC;QAAA;UAEF1K,MAAM,CAAC7F,uBAAuB,CAAC,CAAC+G,oBAAoB,CAClDlB,MAAM,CAACmB,gBAAgB,CAAC;YACtB4E,eAAe,EAAE/F,MAAM,CAACmB,gBAAgB,CAAC;cACvC6E,QAAQ,EAAE,MAAM;cAChBsE,aAAa,EAAbA;YACF,CAAC;UACH,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAE,UAAA,CAAAvJ,IAAA;MAAA;IAAA,GAAAoJ,SAAA;EAAA,CACF,GAAC;EAEF1K,EAAE,CAAC,+DAA+D,EAAE,YAAM;IACxE7G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAA+R,qBAAA,EAAAC,gBAAA;MACR,CAAAD,qBAAA,IAAAC,gBAAA,GAAA3Q,eAAe,EAACuE,OAAO,cAAAmM,qBAAA,eAAvBA,qBAAA,CAAAE,IAAA,CAAAD,gBAAA,EACE;QACEvE,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,SAAS;QACpBC,aAAa,EAAE;MACjB,CAAC,EACD,+DACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB8J,OAAO,EAAE,IAAI;MACb7J,OAAO,EAAE;IACX,CAAC,CACH,CAAC;IACDpB,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACf,oBAAoB,CAC7ClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB+J,WAAW,EAAE,CAAC,YAAY;IAC5B,CAAC,CACH,CAAC;EACH,CAAC,CAAC;EAEFvL,EAAE,CAAC,8DAA8D,EAAE,YAAM;IACvErG,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;IAE3B3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAAsS,sBAAA,EAAAC,iBAAA;MACR,CAAAD,sBAAA,IAAAC,iBAAA,GAAAlR,eAAe,EAACuE,OAAO,cAAA0M,sBAAA,eAAvBA,sBAAA,CAAAL,IAAA,CAAAM,iBAAA,EACE;QACE9E,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,UAAU;QACrBC,aAAa,EAAE;MACjB,CAAC,EACD,uBAAuB,EACvB,kCACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB8J,OAAO,EAAE,IAAI;MACb7J,OAAO,EAAE;IACX,CAAC,CACH,CAAC;IACDpB,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACf,oBAAoB,CAC7ClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB+J,WAAW,EAAE,CAAC,YAAY;IAC5B,CAAC,CACH,CAAC;EACH,CAAC,CAAC;EAEFvL,EAAE,CAAC,kEAAkE,EAAE,YAAM;IAC3ErG,UAAU,CAACmG,GAAG,CAAC,iBAAiB,CAAC;IAEjC3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,iBAAiB;QACzBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAAwS,sBAAA,EAAAC,iBAAA;MACR,CAAAD,sBAAA,IAAAC,iBAAA,GAAApR,eAAe,EAACuE,OAAO,cAAA4M,sBAAA,eAAvBA,sBAAA,CAAAP,IAAA,CAAAQ,iBAAA,EACE;QACEhF,SAAS,EAAE,YAAY;QACvByE,SAAS,EAAE,QAAQ;QACnBC,aAAa,EAAE;MACjB,CAAC,EACD,cACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACxG,kBAAkB,CAAC,CAAC,CAACkD,gBAAgB,CAAC,CAACwE,oBAAoB,CAAC,YAAY,CAAC;IAChFlB,MAAM,CAACvG,iCAAiC,CAAC,CAACyH,oBAAoB,CAAC,YAAY,EAAE,OAAO,CAAC;EACvF,CAAC,CAAC;EAEFvB,EAAE,CAAC,wEAAwE,EAAE,YAAM;IACjF7G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAA0S,sBAAA,EAAAC,iBAAA;MACR,CAAAD,sBAAA,IAAAC,iBAAA,GAAAtR,eAAe,EAACuE,OAAO,cAAA8M,sBAAA,eAAvBA,sBAAA,CAAAT,IAAA,CAAAU,iBAAA,EACE;QACElF,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,SAAS;QACpBC,aAAa,EAAE;MACjB,CAAC,EACD,cACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB8J,OAAO,EAAE,IAAI;MACbC,WAAW,EAAE,CAAC,YAAY;IAC5B,CAAC,CACH,CAAC;EACH,CAAC,CAAC;EAEFvL,EAAE,CAAC,8DAA8D,EAAE,YAAM;IACvErG,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;IAC3B3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAED,IAAM0N,GAAkB,GAAG;MACzBnF,SAAS,EAAE,WAAW;MACtByE,SAAS,EAAE,QAAQ;MACnBC,aAAa,EAAE;IACjB,CAAC;IAEDnS,GAAG,CAAC,YAAM;MAAA,IAAA6S,qBAAA,EAAAC,iBAAA;MACR,CAAAD,qBAAA,IAAAC,iBAAA,GAAAzR,eAAe,EAACwE,cAAc,cAAAgN,qBAAA,eAA9BA,qBAAA,CAAAZ,IAAA,CAAAa,iBAAA,EAAiCF,GAAG,EAAE,WAAW,CAAC;IACpD,CAAC,CAAC;IAEFzL,MAAM,CAAC/G,gBAAgB,CAACiE,QAAQ,CAAC,CAAC,CAAC0O,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC1L,OAAO,CAClEF,MAAM,CAACwD,eAAe,CAAC,CAACxD,MAAM,CAACmB,gBAAgB,CAAC;MAAElF,EAAE,EAAE,yBAAyB;MAAEmF,OAAO,EAAE;IAAG,CAAC,CAAC,CAAC,CAClG,CAAC;EACH,CAAC,CAAC;EAEFzB,EAAE,CAAC,oEAAoE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAsL,UAAA;IAAA,OAAAvL,mBAAA,CAAAI,IAAA,WAAAoL,UAAA;MAAA,kBAAAA,UAAA,CAAAlL,IAAA,GAAAkL,UAAA,CAAAjL,IAAA;QAAA;UACvE/H,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAEDzE,UAAU,CAACmG,GAAG,CAAC,iBAAiB,CAAC;UAAAqM,UAAA,CAAAjL,IAAA;UAAA,OAE3BhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAwL,UAAA;YAAA,IAAAC,qBAAA,EAAAC,iBAAA;YAAA,OAAA3L,mBAAA,CAAAI,IAAA,WAAAwL,UAAA;cAAA,kBAAAA,UAAA,CAAAtL,IAAA,GAAAsL,UAAA,CAAArL,IAAA;gBAAA;kBAAAqL,UAAA,CAAArL,IAAA;kBAAA,QAAAmL,qBAAA,GACF,CAAAC,iBAAA,GAAA/R,eAAe,EAAC2E,cAAc,cAAAmN,qBAAA,uBAA9BA,qBAAA,CAAAlB,IAAA,CAAAmB,iBAAA,EACJ;oBACE3F,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,MAAM;oBACjBC,aAAa,EAAE;kBACjB,CAAC,EACD,yBAAyB,EACzB,EAAE,EACF,aAAa,EACb,IAAI,EACJ,IAAI,EACJ,IACF,CAAC;gBAAA;gBAAA;kBAAA,OAAAkB,UAAA,CAAAjL,IAAA;cAAA;YAAA,GAAA8K,SAAA;UAAA,CACF,GAAC;QAAA;UAEF/L,MAAM,CAACxG,kBAAkB,CAAC,CAAC,CAACkD,gBAAgB,CAAC,CAACwE,oBAAoB,CAAC,WAAW,CAAC;UAC/ElB,MAAM,CAACvG,iCAAiC,CAAC,CAACyH,oBAAoB,CAAC,WAAW,EAAE,UAAU,CAAC;UACvFlB,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACC,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAA4J,UAAA,CAAA7K,IAAA;MAAA;IAAA,GAAA4K,SAAA;EAAA,CAC9C,GAAC;EAEFlM,EAAE,CAAC,iEAAiE,EAAE,YAAM;IAC1E7G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAAsT,sBAAA,EAAAC,iBAAA;MACR,CAAAD,sBAAA,IAAAC,iBAAA,GAAAlS,eAAe,EAACuE,OAAO,cAAA0N,sBAAA,eAAvBA,sBAAA,CAAArB,IAAA,CAAAsB,iBAAA,EACE;QACE9F,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,UAAU;QACrBC,aAAa,EAAE;MACjB,CAAC,EACD,uBAAuB,EACvB,kCACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB8J,OAAO,EAAE,IAAI;MACb7J,OAAO,EAAEpB,MAAM,CAACqM,gBAAgB,CAAC,yBAAyB;IAC5D,CAAC,CACH,CAAC;IACDrM,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACf,oBAAoB,CAC7ClB,MAAM,CAACmB,gBAAgB,CAAC;MACtB+J,WAAW,EAAE,CAAC,YAAY;IAC5B,CAAC,CACH,CAAC;EACH,CAAC,CAAC;EAEFvL,EAAE,CAAC,kEAAkE,EAAE,YAAM;IAC3E7G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDzE,UAAU,CAACmG,GAAG,CAAC,eAAe,CAAC;IAE/B5G,GAAG,CAAC,YAAM;MAAA,IAAAyT,sBAAA,EAAAC,iBAAA;MACR,CAAAD,sBAAA,IAAAC,iBAAA,GAAArS,eAAe,EAACuE,OAAO,cAAA6N,sBAAA,eAAvBA,sBAAA,CAAAxB,IAAA,CAAAyB,iBAAA,EACE;QACEjG,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,QAAQ;QACnBC,aAAa,EAAE;MACjB,CAAC,EACD,cACF,CAAC;IACH,CAAC,CAAC;IAEFhL,MAAM,CAACxG,kBAAkB,CAAC,CAAC,CAACkD,gBAAgB,CAAC,CAACwE,oBAAoB,CAAC,WAAW,CAAC;IAC/ElB,MAAM,CAACvG,iCAAiC,CAAC,CAACyH,oBAAoB,CAAC,WAAW,EAAE,OAAO,CAAC;EACtF,CAAC,CAAC;EAEFvB,EAAE,CAAC,8FAA8F,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAiM,UAAA;IAAA,IAAAC,0BAAA,EAAAC,gBAAA,EAAAC,OAAA;IAAA,OAAArM,mBAAA,CAAAI,IAAA,WAAAkM,UAAA;MAAA,kBAAAA,UAAA,CAAAhM,IAAA,GAAAgM,UAAA,CAAA/L,IAAA;QAAA;UAC3F4L,0BAA0B,GAAGrS,IAAI,CAACC,EAAE,CAAC,CAAC;UAC5CwS,MAAM,CAACC,mBAAmB,GAAG;YAAEL,0BAA0B,EAA1BA;UAA2B,CAAC;UACrDC,gBAAgB,GAAGG,MAAM,CAACE,QAAQ,CAACC,QAAQ;UACjDhQ,MAAM,CAACiQ,cAAc,CAACJ,MAAM,EAAE,UAAU,EAAE;YACxCK,YAAY,EAAE,IAAI;YAClBhP,KAAK,EAAAiP,aAAA,CAAAA,aAAA,KAAON,MAAM,CAACE,QAAQ;cAAEC,QAAQ,EAAE;YAAoB;UAC7D,CAAC,CAAC;UAEF1T,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,QAAQ;YACZmF,OAAO,EAAE,eAAe;YACxBI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBkB,SAAS,EAAE;UACb,CAAC,EACD;YACE/I,EAAE,EAAE,cAAc;YAClBmF,OAAO,EAAE,aAAa;YACtBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBsJ,cAAc,EAAE,UAAU;YAC1B/H,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,IAAI;gBAAEC,SAAS,EAAE,aAAa;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YAC7F;UACF,CAAC,CACF;UAED7M,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YACE+E,OAAO,EAAE,SAATA,OAAOA,CAAAsP,MAAA;cAAA,IAAKpP,QAAQ,GAAAoP,MAAA,CAARpP,QAAQ;cAAA,oBAClBlE,IAAA,CAAChB,yBAAyB;gBAACmF,KAAK,EAAE;kBAAEC,KAAK,EAAEnF,SAAS;kBAAEsL,OAAO,EAAE;oBAAErI,EAAE,EAAE,EAAE;oBAAEsF,IAAI,EAAE;kBAAQ;gBAAW,CAAE;gBAAAtD,QAAA,EACjGA;cAAQ,CACgB,CAAC;YAAA;UAEhC,CACF,CAAC;UAEK0O,OAAO,GAAG,qCAAqC;UAAAC,UAAA,CAAA/L,IAAA;UAAA,OAE/ChI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA+M,UAAA;YAAA,IAAAC,sBAAA,EAAAC,iBAAA;YAAA,OAAAlN,mBAAA,CAAAI,IAAA,WAAA+M,UAAA;cAAA,kBAAAA,UAAA,CAAA7M,IAAA,GAAA6M,UAAA,CAAA5M,IAAA;gBAAA;kBAAA4M,UAAA,CAAA5M,IAAA;kBAAA,QAAA0M,sBAAA,GACF,CAAAC,iBAAA,GAAAtT,eAAe,EAAC2E,cAAc,cAAA0O,sBAAA,uBAA9BA,sBAAA,CAAAzC,IAAA,CAAA0C,iBAAA,EACJ;oBACElH,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,QAAQ;oBACnBC,aAAa,EAAEpR,6BAA6B,CAAC,QAAQ;kBACvD,CAAC,EACD+S,OAAO,EACP,EAAE,EACF,eAAe,EACf,IAAI,EACJ,CAAC,QAAQ,CAAC,EACV,IACF,CAAC;gBAAA;gBAAA;kBAAA,OAAAc,UAAA,CAAAxM,IAAA;cAAA;YAAA,GAAAqM,SAAA;UAAA,CACF,GAAC;QAAA;UAEFtN,MAAM,CAACyM,0BAA0B,CAAC,CAACvL,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;UAC7DlB,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBlF,EAAE,EAAE,sBAAsB;YAC1BiP,WAAW,EAAE,CAAC,QAAQ;UACxB,CAAC,CACH,CAAC;UAEDlO,MAAM,CAACiQ,cAAc,CAACJ,MAAM,EAAE,UAAU,EAAE;YACxCK,YAAY,EAAE,IAAI;YAClBhP,KAAK,EAAAiP,aAAA,CAAAA,aAAA,KAAON,MAAM,CAACE,QAAQ;cAAEC,QAAQ,EAAEN;YAAgB;UACzD,CAAC,CAAC;UACF,OAAOG,MAAM,CAACC,mBAAmB;QAAA;QAAA;UAAA,OAAAF,UAAA,CAAA3L,IAAA;MAAA;IAAA,GAAAuL,SAAA;EAAA,CAClC,GAAC;EAEF7M,EAAE,CAAC,8DAA8D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAmN,UAAA;IAAA,IAAAC,cAAA,EAAAC,KAAA;IAAA,OAAAtN,mBAAA,CAAAI,IAAA,WAAAmN,UAAA;MAAA,kBAAAA,UAAA,CAAAjN,IAAA,GAAAiN,UAAA,CAAAhN,IAAA;QAAA;UAC3D8M,cAAc,GAAGvT,IAAI,CAACC,EAAE,CAAC,CAAC;UAChCwS,MAAM,CAACiB,gBAAgB,CAACnU,wBAAwB,EAAEgU,cAAc,CAAC;UACjErU,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,gBAAgB;YACpBmF,OAAO,EAAE,eAAe;YACxBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBsJ,cAAc,EAAE,UAAU;YAC1B/H,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,IAAI;gBAAEC,SAAS,EAAE,cAAc;gBAAEC,SAAS,EAAE,CAAC;cAAE,CAAC;YACjF;UACF,CAAC,CACF;UAED5M,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAAA8P,UAAA,CAAAhN,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAwN,UAAA;YAAA,IAAAC,sBAAA,EAAAC,iBAAA;YAAA,OAAA3N,mBAAA,CAAAI,IAAA,WAAAwN,UAAA;cAAA,kBAAAA,UAAA,CAAAtN,IAAA,GAAAsN,UAAA,CAAArN,IAAA;gBAAA;kBAAAqN,UAAA,CAAArN,IAAA;kBAAA,QAAAmN,sBAAA,GACF,CAAAC,iBAAA,GAAA/T,eAAe,EAAC2E,cAAc,cAAAmP,sBAAA,uBAA9BA,sBAAA,CAAAlD,IAAA,CAAAmD,iBAAA,EACJ;oBACE3H,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,SAAS;oBACpBC,aAAa,EAAEpR,6BAA6B,CAAC,SAAS;kBACxD,CAAC,EACD,gBAAgB,EAChB,EAAE,EACF,gBACF,CAAC;gBAAA;gBAAA;kBAAA,OAAAsU,UAAA,CAAAjN,IAAA;cAAA;YAAA,GAAA8M,SAAA;UAAA,CACF,GAAC;QAAA;UAEF/N,MAAM,CAAC2N,cAAc,CAAC,CAACzL,gBAAgB,CAAC,CAAC;UACnC0L,KAAK,GAAGD,cAAc,CAACpS,IAAI,CAAC4S,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;UAC7CnO,MAAM,CAAC4N,KAAK,CAACQ,MAAM,CAACC,KAAK,CAAC,CAACnO,OAAO,CAAC,CAAC,cAAc,CAAC,CAAC;UAEpD2M,MAAM,CAACyB,mBAAmB,CAAC3U,wBAAwB,EAAEgU,cAAc,CAAC;QAAA;QAAA;UAAA,OAAAE,UAAA,CAAA5M,IAAA;MAAA;IAAA,GAAAyM,SAAA;EAAA,CACrE,GAAC;EAEF/N,EAAE,CAAC,8DAA8D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAgO,UAAA;IAAA,IAAAC,YAAA;IAAA,OAAAlO,mBAAA,CAAAI,IAAA,WAAA+N,UAAA;MAAA,kBAAAA,UAAA,CAAA7N,IAAA,GAAA6N,UAAA,CAAA5N,IAAA;QAAA;UACjEgM,MAAM,CAAC6B,wCAAwC,GAAG,IAAI;UACtD1U,oBAAoB,CAACM,iBAAiB,CAAC;YAAE2B,EAAE,EAAE,WAAW;YAAEsF,IAAI,EAAE;UAAQ,CAAU,CAAC;UAC7EiN,YAAY,GAAGpU,IAAI,CAACC,EAAE,CAAC,CAAC;UAC9ByH,QAAQ,CAACgM,gBAAgB,CAAC,oCAAoC,EAAEU,YAAY,CAAC;UAC7ElV,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,gBAAgB;YACpBmF,OAAO,EAAE,kBAAkB;YAC3BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBsJ,cAAc,EAAE,UAAU;YAC1B/H,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,IAAI;gBAAEC,SAAS,EAAE,cAAc;gBAAEC,SAAS,EAAE,CAAC;cAAE,CAAC;YACjF;UACF,CAAC,CACF;UAED5M,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAAA0Q,UAAA,CAAA5N,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAoO,UAAA;YAAA,IAAAC,sBAAA,EAAAC,iBAAA;YAAA,OAAAvO,mBAAA,CAAAI,IAAA,WAAAoO,UAAA;cAAA,kBAAAA,UAAA,CAAAlO,IAAA,GAAAkO,UAAA,CAAAjO,IAAA;gBAAA;kBAAAiO,UAAA,CAAAjO,IAAA;kBAAA,QAAA+N,sBAAA,GACF,CAAAC,iBAAA,GAAA3U,eAAe,EAAC2E,cAAc,cAAA+P,sBAAA,uBAA9BA,sBAAA,CAAA9D,IAAA,CAAA+D,iBAAA,EACJ;oBACEvI,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,YAAY;oBACvBC,aAAa,EAAEpR,6BAA6B,CAAC,YAAY;kBAC3D,CAAC,EACD,eAAe,EACf,EAAE,EACF,gBAAgB,EAChB,IAAI,EACJ,IAAI,EACJ,WACF,CAAC;gBAAA;kBAAAkV,UAAA,CAAAjO,IAAA;kBAAA,OACKkO,OAAO,CAACC,OAAO,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAF,UAAA,CAAA7N,IAAA;cAAA;YAAA,GAAA0N,SAAA;UAAA,CACxB,GAAC;QAAA;UAEF3O,MAAM,CAAChG,oBAAoB,CAAC,CAACkH,oBAAoB,CAAC,WAAW,CAAC;UAC9DlB,MAAM,CAACwO,YAAY,CAAC,CAACtM,gBAAgB,CAAC,CAAC;UACvCJ,QAAQ,CAACwM,mBAAmB,CAAC,oCAAoC,EAAEE,YAAY,CAAC;UAChF3B,MAAM,CAAC6B,wCAAwC,GAAG,KAAK;QAAA;QAAA;UAAA,OAAAD,UAAA,CAAAxN,IAAA;MAAA;IAAA,GAAAsN,SAAA;EAAA,CACxD,GAAC;EAEF5O,EAAE,CAAC,2DAA2D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA0O,UAAA;IAAA,IAAAC,WAAA;IAAA,OAAA5O,mBAAA,CAAAI,IAAA,WAAAyO,UAAA;MAAA,kBAAAA,UAAA,CAAAvO,IAAA,GAAAuO,UAAA,CAAAtO,IAAA;QAAA;UACxDqO,WAAW,GAAG9U,IAAI,CAACC,EAAE,CAAC,CAAC;UAC7BwS,MAAM,CAACuC,SAAS,GAAG;YAAEC,MAAM,EAAE,EAAE;YAAEH,WAAW,EAAXA;UAAY,CAAC;UAC9C5V,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,eAAe;YACnBmF,OAAO,EAAE,SAAS;YAClBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBsJ,cAAc,EAAE,UAAU;YAC1B/H,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,IAAI;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YAC3F;UACF,CAAC,CACF;UAED7M,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAAAoR,UAAA,CAAAtO,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA+O,UAAA;YAAA,IAAAC,sBAAA,EAAAC,kBAAA;YAAA,OAAAlP,mBAAA,CAAAI,IAAA,WAAA+O,UAAA;cAAA,kBAAAA,UAAA,CAAA7O,IAAA,GAAA6O,UAAA,CAAA5O,IAAA;gBAAA;kBAAA4O,UAAA,CAAA5O,IAAA;kBAAA,QAAA0O,sBAAA,GACF,CAAAC,kBAAA,GAAAtV,eAAe,EAAC2E,cAAc,cAAA0Q,sBAAA,uBAA9BA,sBAAA,CAAAzE,IAAA,CAAA0E,kBAAA,EACJ;oBACElJ,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,WAAW;oBACtBC,aAAa,EAAEpR,6BAA6B,CAAC,WAAW;kBAC1D,CAAC,EACD,mBAAmB,EACnB,EAAE,EACF,eACF,CAAC;gBAAA;gBAAA;kBAAA,OAAA6V,UAAA,CAAAxO,IAAA;cAAA;YAAA,GAAAqO,SAAA;UAAA,CACF,GAAC;QAAA;UAEFtP,MAAM,CAACkP,WAAW,CAAC,CAAChN,gBAAgB,CAAC,CAAC;UACtC,OAAO2K,MAAM,CAACuC,SAAS;QAAA;QAAA;UAAA,OAAAD,UAAA,CAAAlO,IAAA;MAAA;IAAA,GAAAgO,SAAA;EAAA,CACxB,GAAC;EAEFtP,EAAE,CAAC,kFAAkF,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAmP,UAAA;IAAA,OAAApP,mBAAA,CAAAI,IAAA,WAAAiP,UAAA;MAAA,kBAAAA,UAAA,CAAA/O,IAAA,GAAA+O,UAAA,CAAA9O,IAAA;QAAA;UACrF5H,gBAAgB,CAACqG,QAAQ,CAAC;YACxBC,IAAI,EAAE;cAAE,WAAW,EAAE;gBAAEqQ,MAAM,EAAE,UAAU;gBAAEC,UAAU,EAAE;cAA2B;YAAE,CAAC;YACrF7U,QAAQ,EAAE;cACR,WAAW,EAAE,CACX;gBACEiB,EAAE,EAAErC,6BAA6B,CAAC,OAAO,CAAC;gBAC1CwH,OAAO,EAAE,EAAE;gBACXI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;gBAC/BR,IAAI,EAAE;kBAAEtH,EAAE,EAAE,WAAW;kBAAEsF,IAAI,EAAE;gBAAO,CAAC;gBACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC;cACjB,CAAC;YAEL;UACF,CAAC,CAAC;UAEFhL,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAAA4R,UAAA,CAAA9O,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAuP,UAAA;YAAA,OAAAxP,mBAAA,CAAAI,IAAA,WAAAqP,UAAA;cAAA,kBAAAA,UAAA,CAAAnP,IAAA,GAAAmP,UAAA,CAAAlP,IAAA;gBAAA;kBAAAkP,UAAA,CAAAlP,IAAA;kBAAA,OACFkO,OAAO,CAACC,OAAO,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAe,UAAA,CAAA9O,IAAA;cAAA;YAAA,GAAA6O,SAAA;UAAA,CACxB,GAAC;QAAA;UAEF9P,MAAM,CAAClF,iBAAiB,CAACI,YAAY,CAAC,CAACgG,oBAAoB,CAAC;YAAE8O,KAAK,EAAE;UAAK,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAL,UAAA,CAAA1O,IAAA;MAAA;IAAA,GAAAyO,SAAA;EAAA,CAC7E,GAAC;EAEF/P,EAAE,CAAC,2DAA2D,EAAE,YAAM;IACpE,IAAAsQ,aAAA,GAAqBnX,UAAU,CAC7B,UAAAoX,MAAA;QAAA,IAAGrQ,MAAM,GAAAqQ,MAAA,CAANrQ,MAAM;QAAA,OACPhG,cAAc,CAAC;UACbgG,MAAM,EAANA,MAAM;UACNC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QACE+E,OAAO,EAAPA,OAAO;QACPoS,YAAY,EAAE;UAAEtQ,MAAM,EAAE;QAAoC;MAC9D,CACF,CAAC;MAVOuQ,QAAQ,GAAAH,aAAA,CAARG,QAAQ;IAYhBA,QAAQ,CAAC;MAAEvQ,MAAM,EAAE;IAAK,CAAC,CAAC;IAE1BG,MAAM,CAACxG,kBAAkB,CAAC,CAAC,CAACgD,eAAe,CAAC,CAAC0E,oBAAoB,CAAC,IAAI,CAAC;EACzE,CAAC,CAAC;EAEFvB,EAAE,CAAC,2EAA2E,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA8P,UAAA;IAAA,IAAA3O,WAAA,EAAA4O,aAAA,EAAAvQ,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA6P,UAAA;MAAA,kBAAAA,UAAA,CAAA3P,IAAA,GAAA2P,UAAA,CAAA1P,IAAA;QAAA;UAC9E/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,YAAY;YAChBmF,OAAO,EAAE,MAAM;YACfI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,2BAA2B;YAC/BmF,OAAO,EAAE,mBAAmB;YAC5BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAY,CAAC;YAC5CsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBE,mBAAmB,EAAE;UACvB,CAAC,CACF;UACKtC,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UACzDxI,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAAA6Q,aAAA,GAERxX,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAuQ,aAAA,CAANvQ,MAAM;UAAAwQ,UAAA,CAAA1P,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAiQ,UAAA;YAAA,OAAAlQ,mBAAA,CAAAI,IAAA,WAAA+P,UAAA;cAAA,kBAAAA,UAAA,CAAA7P,IAAA,GAAA6P,UAAA,CAAA5P,IAAA;gBAAA;kBAAA4P,UAAA,CAAA5P,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAyV,UAAA,CAAAxP,IAAA;cAAA;YAAA,GAAAuP,SAAA;UAAA,CACjE,GAAC;QAAA;UAEF7V,mBAAmB,CAACiK,SAAS,CAAC,CAAC;UAE/B/L,GAAG,CAAC,YAAM;YAAA,IAAA6X,sBAAA,EAAAC,kBAAA;YACR,CAAAD,sBAAA,IAAAC,kBAAA,GAAAzW,eAAe,EAACuE,OAAO,cAAAiS,sBAAA,eAAvBA,sBAAA,CAAA5F,IAAA,CAAA6F,kBAAA,EACE;cACErK,SAAS,EAAE,WAAW;cACtByE,SAAS,EAAE,SAAS;cACpBC,aAAa,EAAE;YACjB,CAAC,EACD,cACF,CAAC;UACH,CAAC,CAAC;UAEFhL,MAAM,CAACrF,mBAAmB,CAAC,CAACuG,oBAAoB,CAACpG,iBAAiB,CAACE,QAAQ,CAAC;UAC5EgF,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE,gBAAgB;YACtBiM,MAAM,EAAEpO,MAAM,CAACmB,gBAAgB,CAAC;cAAEyP,QAAQ,EAAE;YAAQ,CAAC;UACvD,CAAC,CACH,CAAC;UAEDlP,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAmO,UAAA,CAAAtP,IAAA;MAAA;IAAA,GAAAoP,SAAA;EAAA,CAC1B,GAAC;EAEF1Q,EAAE,CAAC,8DAA8D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAsQ,UAAA;IAAA,IAAA7I,UAAA;IAAA,OAAA1H,mBAAA,CAAAI,IAAA,WAAAoQ,UAAA;MAAA,kBAAAA,UAAA,CAAAlQ,IAAA,GAAAkQ,UAAA,CAAAjQ,IAAA;QAAA;UACjEvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3BxG,gBAAgB,CAACqG,QAAQ,CAAC;YACxBtE,QAAQ,EAAE;cACR,WAAW,EAAE,CACX;gBACEiB,EAAE,EAAErC,6BAA6B,CAAC,aAAa,CAAC;gBAChDwH,OAAO,EAAE,EAAE;gBACXI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;gBAC/BR,IAAI,EAAE;kBAAEtH,EAAE,EAAE,WAAW;kBAAEsF,IAAI,EAAE;gBAAO,CAAC;gBACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC;cACjB,CAAC;YAEL;UACF,CAAC,CAAC;UAEFhL,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC;UAEKiK,UAAU,GAAG;YACjB/L,EAAE,EAAE,OAAO;YACXsF,IAAI,EAAE,WAAW;YACjBY,IAAI,EAAE,KAAK;YACXgG,IAAI,EAAE,EAAE;YACRC,IAAI,EAAE,IAAIC,IAAI,CAAC,EAAE,EAAE,WAAW;UAChC,CAAC;UAAAyI,UAAA,CAAAjQ,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAwQ,UAAA;YAAA,IAAAC,sBAAA,EAAAC,kBAAA;YAAA,OAAA3Q,mBAAA,CAAAI,IAAA,WAAAwQ,UAAA;cAAA,kBAAAA,UAAA,CAAAtQ,IAAA,GAAAsQ,UAAA,CAAArQ,IAAA;gBAAA;kBAAAqQ,UAAA,CAAArQ,IAAA;kBAAA,QAAAmQ,sBAAA,GACF,CAAAC,kBAAA,GAAA/W,eAAe,EAAC2E,cAAc,cAAAmS,sBAAA,uBAA9BA,sBAAA,CAAAlG,IAAA,CAAAmG,kBAAA,EACJ;oBACE3K,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,aAAa;oBACxBC,aAAa,EAAEpR,6BAA6B,CAAC,aAAa;kBAC5D,CAAC,EACD,uBAAuB,EACvB,EAAE,EACF,iBAAiB,EACjB,CAACoO,UAAU,CAAC,EACZ,IAAI,EACJ,IACF,CAAC;gBAAA;gBAAA;kBAAA,OAAAkJ,UAAA,CAAAjQ,IAAA;cAAA;YAAA,GAAA8P,SAAA;UAAA,CACF,GAAC;QAAA;UAEF/Q,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBlF,EAAE,EAAE,wBAAwB;YAC5BuM,WAAW,EAAExI,MAAM,CAACwD,eAAe,CAAC,CAACxD,MAAM,CAACmB,gBAAgB,CAAC;cAAElF,EAAE,EAAE,OAAO;cAAEsF,IAAI,EAAE;YAAY,CAAC,CAAC,CAAC;UACnG,CAAC,CACH,CAAC;QAAA;QAAA;UAAA,OAAAuP,UAAA,CAAA7P,IAAA;MAAA;IAAA,GAAA4P,SAAA;EAAA,CACF,GAAC;EAEFlR,EAAE,CAAC,6DAA6D,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA4Q,UAAA;IAAA,IAAAC,+BAAA,EAAA1E,gBAAA;IAAA,OAAApM,mBAAA,CAAAI,IAAA,WAAA2Q,UAAA;MAAA,kBAAAA,UAAA,CAAAzQ,IAAA,GAAAyQ,UAAA,CAAAxQ,IAAA;QAAA;UAC1DuQ,+BAA+B,GAAGhX,IAAI,CAACC,EAAE,CAAC,CAAC;UACjDwS,MAAM,CAACC,mBAAmB,GAAG;YAAEsE,+BAA+B,EAA/BA;UAAgC,CAAC;UAC1D1E,gBAAgB,GAAGG,MAAM,CAACE,QAAQ,CAACC,QAAQ;UACjDhQ,MAAM,CAACiQ,cAAc,CAACJ,MAAM,EAAE,UAAU,EAAE;YACxCK,YAAY,EAAE,IAAI;YAClBhP,KAAK,EAAAiP,aAAA,CAAAA,aAAA,KAAON,MAAM,CAACE,QAAQ;cAAEC,QAAQ,EAAE;YAAoB;UAC7D,CAAC,CAAC;UAEF1T,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3B3E,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,iBAAiB;YACrBmF,OAAO,EAAE,oBAAoB;YAC7BI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBsJ,cAAc,EAAE,UAAU;YAC1B/H,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,IAAI;gBAAEC,SAAS,EAAE,aAAa;gBAAEC,SAAS,EAAE;kBAAEC,OAAO,EAAE;gBAAG;cAAE,CAAC;YAC7F;UACF,CAAC,CACF;UAED7M,UAAU,CACR;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YACE+E,OAAO,EAAE,SAATA,OAAOA,CAAAuT,MAAA;cAAA,IAAKrT,QAAQ,GAAAqT,MAAA,CAARrT,QAAQ;cAAA,oBAClBlE,IAAA,CAAChB,yBAAyB;gBAACmF,KAAK,EAAE;kBAAEC,KAAK,EAAEnF,SAAS;kBAAEsL,OAAO,EAAE;oBAAErI,EAAE,EAAE,EAAE;oBAAEsF,IAAI,EAAE;kBAAQ;gBAAW,CAAE;gBAAAtD,QAAA,EACjGA;cAAQ,CACgB,CAAC;YAAA;UAEhC,CACF,CAAC;UAAAoT,UAAA,CAAAxQ,IAAA;UAAA,OAEKhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAgR,UAAA;YAAA,IAAAC,sBAAA,EAAAC,kBAAA;YAAA,OAAAnR,mBAAA,CAAAI,IAAA,WAAAgR,UAAA;cAAA,kBAAAA,UAAA,CAAA9Q,IAAA,GAAA8Q,UAAA,CAAA7Q,IAAA;gBAAA;kBAAA6Q,UAAA,CAAA7Q,IAAA;kBAAA,QAAA2Q,sBAAA,GACF,CAAAC,kBAAA,GAAAvX,eAAe,EAAC2E,cAAc,cAAA2S,sBAAA,uBAA9BA,sBAAA,CAAA1G,IAAA,CAAA2G,kBAAA,EACJ;oBACEnL,SAAS,EAAE,WAAW;oBACtByE,SAAS,EAAE,aAAa;oBACxBC,aAAa,EAAEpR,6BAA6B,CAAC,aAAa;kBAC5D,CAAC,EACD,iBAAiB,EACjB,EAAE,EACF,iBACF,CAAC;gBAAA;gBAAA;kBAAA,OAAA8X,UAAA,CAAAzQ,IAAA;cAAA;YAAA,GAAAsQ,SAAA;UAAA,CACF,GAAC;QAAA;UAEFvR,MAAM,CAACoR,+BAA+B,CAAC,CAAClQ,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;UAElElE,MAAM,CAACiQ,cAAc,CAACJ,MAAM,EAAE,UAAU,EAAE;YACxCK,YAAY,EAAE,IAAI;YAClBhP,KAAK,EAAAiP,aAAA,CAAAA,aAAA,KAAON,MAAM,CAACE,QAAQ;cAAEC,QAAQ,EAAEN;YAAgB;UACzD,CAAC,CAAC;UACF,OAAOG,MAAM,CAACC,mBAAmB;QAAA;QAAA;UAAA,OAAAuE,UAAA,CAAApQ,IAAA;MAAA;IAAA,GAAAkQ,SAAA;EAAA,CAClC,GAAC;EAEFxR,EAAE,CAAC,0DAA0D,EAAE,YAAM;IACnErG,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;IAE3B3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAA8Y,qBAAA,EAAAC,kBAAA;MACR,CAAAD,qBAAA,IAAAC,kBAAA,GAAA1X,eAAe,EAAC0E,kBAAkB,cAAA+S,qBAAA,eAAlCA,qBAAA,CAAA7G,IAAA,CAAA8G,kBAAA,EACE;QACEtL,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,WAAW;QACtBC,aAAa,EAAEpR,6BAA6B,CAAC,WAAW;MAC1D,CAAC,EACD;QACEuI,IAAI,EAAE,mBAAmB;QACzBmD,UAAU,EAAE,WAAW;QACvBuM,kBAAkB,EAAE,QAAQ;QAC5BtM,eAAe,EAAE,CAAC;UAAEC,SAAS,EAAE,IAAI;UAAEC,SAAS,EAAE,WAAW;UAAEC,SAAS,EAAE;YAAEC,OAAO,EAAE;UAAE,CAAC;UAAEmM,YAAY,EAAE;QAAK,CAAC,CAAC;QAC7GC,aAAa,EAAE,CAAC;QAChBC,QAAQ,EAAE,CAAC;MACb,CAAC,EACD,wBACF,CAAC;IACH,CAAC,CAAC;IAEFhS,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MACtBiM,cAAc,EAAE,SAAS;MACzBhM,OAAO,EAAE;IACX,CAAC,CACH,CAAC;EACH,CAAC,CAAC;EAEFzB,EAAE,CAAC,8DAA8D,EAAE,YAAM;IACvErG,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;IAE3B3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAAoZ,sBAAA,EAAAC,kBAAA;MACR,CAAAD,sBAAA,IAAAC,kBAAA,GAAAhY,eAAe,EAAC0E,kBAAkB,cAAAqT,sBAAA,eAAlCA,sBAAA,CAAAnH,IAAA,CAAAoH,kBAAA,EACE;QACE5L,SAAS,EAAE,WAAW;QACtByE,SAAS,EAAE,WAAW;QACtBC,aAAa,EAAEpR,6BAA6B,CAAC,WAAW;MAC1D,CAAC,EACD;QACEuI,IAAI,EAAE,mBAAmB;QACzBmD,UAAU,EAAE,WAAW;QACvBuM,kBAAkB,EAAE,WAAW;QAC/BtM,eAAe,EAAE,CAAC;UAAEC,SAAS,EAAE,QAAQ;UAAEC,SAAS,EAAE,aAAa;UAAEC,SAAS,EAAE,CAAC,CAAC;UAAEoM,YAAY,EAAE;QAAS,CAAC,CAAC;QAC3GC,aAAa,EAAE,CAAC;QAChBC,QAAQ,EAAE,CAAC,CAAC;QACZG,aAAa,EAAE;MACjB,CAAC,EACD,eACF,CAAC;IACH,CAAC,CAAC;IAEFnS,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACC,gBAAgB,CAAC,CAAC;EAC/C,CAAC,CAAC;EAEFvC,EAAE,CAAC,uEAAuE,EAAE,YAAM;IAChFrG,UAAU,CAACmG,GAAG,CAAC,iBAAiB,CAAC;IAEjC3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,iBAAiB;QACzBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAEDlF,GAAG,CAAC,YAAM;MAAA,IAAAuZ,sBAAA,EAAAC,kBAAA;MACR,CAAAD,sBAAA,IAAAC,kBAAA,GAAAnY,eAAe,EAAC0E,kBAAkB,cAAAwT,sBAAA,eAAlCA,sBAAA,CAAAtH,IAAA,CAAAuH,kBAAA,EACE;QACE/L,SAAS,EAAE,YAAY;QACvByE,SAAS,EAAE,SAAS;QACpBC,aAAa,EAAEpR,6BAA6B,CAAC,SAAS;MACxD,CAAC,EACD;QACEuI,IAAI,EAAE,mBAAmB;QACzBmD,UAAU,EAAE,YAAY;QACxBuM,kBAAkB,EAAE,SAAS;QAC7BtM,eAAe,EAAE,CAAC;UAAEC,SAAS,EAAE,MAAM;UAAEC,SAAS,EAAE,WAAW;UAAEC,SAAS,EAAE,CAAC,CAAC;UAAEoM,YAAY,EAAE;QAAO,CAAC,CAAC;QACrGC,aAAa,EAAE,CAAC;QAChBC,QAAQ,EAAE,CAAC;MACb,CAAC,EACD,sBACF,CAAC;IACH,CAAC,CAAC;IAEFhS,MAAM,CAACxG,kBAAkB,CAAC,CAAC,CAACkD,gBAAgB,CAAC,CAACwE,oBAAoB,CAAC,YAAY,CAAC;IAChFlB,MAAM,CAACvG,iCAAiC,CAAC,CAACyH,oBAAoB,CAAC,YAAY,EAAE,mBAAmB,CAAC;IACjGlB,MAAM,CAACpF,cAAc,CAAC,CAACqH,GAAG,CAACC,gBAAgB,CAAC,CAAC;EAC/C,CAAC,CAAC;EAEFvC,EAAE,CAAC,+DAA+D,EAAE,YAAM;IACxE,IAAM0E,UAAU,GAAGjK,IAAI,CAACC,EAAE,CAAC,CAAC;IAC5B,IAAMiY,SAAS,GAAGlY,IAAI,CAACC,EAAE,CAAC,CAAC;IAC3B,IAAMkY,eAAe,GAAGnY,IAAI,CAACC,EAAE,CAAC,CAAC;IACjC,IAAMmY,OAAO,GAAGpY,IAAI,CAACC,EAAE,CAAC,CAAC;IAEzB,IAAMoY,cAAc,GAAG,SAAjBA,cAAcA,CAAAC,MAAA;MAAA,IAAMzU,QAAQ,GAAAyU,MAAA,CAARzU,QAAQ;MAAA,oBAChClE,IAAA,CAAChB,yBAAyB;QACxBmF,KAAK,EAAE;UACLC,KAAK,EAAEnF,SAAS;UAChBqL,UAAU,EAAVA,UAAU;UACViO,SAAS,EAATA,SAAS;UACTC,eAAe,EAAfA,eAAe;UACfC,OAAO,EAAPA;QACF,CAAE;QAAAvU,QAAA,EAEDA;MAAQ,CACgB,CAAC;IAAA,CAC7B;IAED,IAAA0U,aAAA,GAAqB7Z,UAAU,CAC7B,UAAA8Z,MAAA;QAAA,IAAG/S,MAAM,GAAA+S,MAAA,CAAN/S,MAAM;QAAA,OACPhG,cAAc,CAAC;UACbgG,MAAM,EAANA,MAAM;UACNC,MAAM,EAAE,CAAC9G,SAAS;QACpB,CAAC,CAAC;MAAA,GACJ;QACE+E,OAAO,EAAE0U,cAAc;QACvBtC,YAAY,EAAE;UAAEtQ,MAAM,EAAE;QAA6B;MACvD,CACF,CAAC;MAVOuQ,QAAQ,GAAAuC,aAAA,CAARvC,QAAQ;IAYdlX,oBAAoB,CAACqE,QAAQ,CAAemC,eAAe,CAAC,IAAI,CAAC;IACnE0Q,QAAQ,CAAC;MAAEvQ,MAAM,EAAE;IAAY,CAAC,CAAC;IAEjCG,MAAM,CAACqE,UAAU,CAAC,CAACnD,oBAAoB,CAAC,IAAI,CAAC;IAC7ClB,MAAM,CAACsS,SAAS,CAAC,CAACpR,oBAAoB,CAAC,IAAI,CAAC;IAC5ClB,MAAM,CAACuS,eAAe,CAAC,CAACrR,oBAAoB,CAAC,IAAI,CAAC;IAClDlB,MAAM,CAACwS,OAAO,CAAC,CAACtR,oBAAoB,CAAC,IAAI,CAAC;EAC5C,CAAC,CAAC;EAEFvB,EAAE,CAAC,mEAAmE,EAAE,YAAM;IAC5ErG,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;IAC3B3G,UAAU,CACR;MAAA,OACEe,cAAc,CAAC;QACbgG,MAAM,EAAE,WAAW;QACnBC,MAAM,EAAE,CAAC9G,SAAS;MACpB,CAAC,CAAC;IAAA,GACJ;MAAE+E,OAAO,EAAPA;IAAQ,CACZ,CAAC;IAED,IAAM0N,GAAkB,GAAG;MACzBnF,SAAS,EAAE,WAAW;MACtByE,SAAS,EAAE,aAAa;MACxBC,aAAa,EAAEpR,6BAA6B,CAAC,aAAa;IAC5D,CAAC;IAEDf,GAAG,CAAC,YAAM;MAAA,IAAAga,sBAAA,EAAAC,kBAAA;MACR,CAAAD,sBAAA,IAAAC,kBAAA,GAAA5Y,eAAe,EAACwE,cAAc,cAAAmU,sBAAA,eAA9BA,sBAAA,CAAA/H,IAAA,CAAAgI,kBAAA,EAAiCrH,GAAG,EAAE,SAAS,CAAC;IAClD,CAAC,CAAC;IAEF5S,GAAG,CAAC,YAAM;MAAA,IAAAka,sBAAA,EAAAC,kBAAA;MACR,CAAAD,sBAAA,IAAAC,kBAAA,GAAA9Y,eAAe,EAACyE,MAAM,cAAAoU,sBAAA,eAAtBA,sBAAA,CAAAjI,IAAA,CAAAkI,kBAAA,EAAyB,SAAS,CAAC;IACrC,CAAC,CAAC;IAEFhT,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MAAEC,OAAO,EAAE,SAAS;MAAEI,IAAI,EAAErI,eAAe,CAAC4K;IAAU,CAAC,CACjF,CAAC;IACD/D,MAAM,CAACpF,cAAc,CAAC,CAACsG,oBAAoB,CACzClB,MAAM,CAACmB,gBAAgB,CAAC;MAAEK,IAAI,EAAErI,eAAe,CAAC4K,SAAS;MAAE3C,OAAO,EAAEpB,MAAM,CAACiT,cAAc,CAAC,SAAS;IAAE,CAAC,CACxG,CAAC;EACH,CAAC,CAAC;EAEFtT,EAAE,CAAC,sEAAsE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA2S,UAAA;IAAA,IAAAC,aAAA,EAAApT,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA0S,UAAA;MAAA,kBAAAA,UAAA,CAAAxS,IAAA,GAAAwS,UAAA,CAAAvS,IAAA;QAAA;UACzE/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,gBAAgB;YACpBmF,OAAO,EAAE,UAAU;YACnBI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,iBAAiB;YACrBmF,OAAO,EAAE,OAAO;YAChBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBmH,OAAO,EAAE,IAAI;YACboI,eAAe,EAAE;UACnB,CAAC,CACF;UACD5Y,mBAAmB,CAACH,iBAAiB,CAAC;YAAEC,OAAO,EAAE,KAAK;YAAE+Y,MAAM,EAAE;UAAiB,CAAC,CAAC;UAAAH,aAAA,GAEhEra,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAoT,aAAA,CAANpT,MAAM;UAAAqT,UAAA,CAAAvS,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAgT,UAAA;YAAA,OAAAjT,mBAAA,CAAAI,IAAA,WAAA8S,UAAA;cAAA,kBAAAA,UAAA,CAAA5S,IAAA,GAAA4S,UAAA,CAAA3S,IAAA;gBAAA;kBAAA2S,UAAA,CAAA3S,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAwY,UAAA,CAAAvS,IAAA;cAAA;YAAA,GAAAsS,SAAA;UAAA,CACjE,GAAC;QAAA;UAEFvT,MAAM,CAACvF,mBAAmB,CAAC,CAACyH,gBAAgB,CAAC,CAAC;UAC9ClC,MAAM,CAACxF,WAAW,CAAC,CAAC0G,oBAAoB,CAAClB,MAAM,CAACmB,gBAAgB,CAAC;YAAEC,OAAO,EAAE;UAAW,CAAC,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAgS,UAAA,CAAAnS,IAAA;MAAA;IAAA,GAAAiS,SAAA;EAAA,CAC3F,GAAC;EAEFvT,EAAE,CAAC,wEAAwE,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAkT,UAAA;IAAA,IAAA/R,WAAA,EAAAgS,aAAA,EAAA3T,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAiT,UAAA;MAAA,kBAAAA,UAAA,CAAA/S,IAAA,GAAA+S,UAAA,CAAA9S,IAAA;QAAA;UAC3E/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,gBAAgB;YACpBmF,OAAO,EAAE,UAAU;YACnBI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,mBAAmB;YACvBmF,OAAO,EAAE,OAAO;YAChBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBmH,OAAO,EAAE,IAAI;YACboI,eAAe,EAAE;UACnB,CAAC,CACF;UACD5Y,mBAAmB,CAACH,iBAAiB,CAAC;YAAEC,OAAO,EAAE,KAAK;YAAE+Y,MAAM,EAAE;UAAQ,CAAC,CAAC;UACpE5R,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UAAA4R,aAAA,GAEtC5a,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAA2T,aAAA,CAAN3T,MAAM;UAAA4T,UAAA,CAAA9S,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAqT,UAAA;YAAA,OAAAtT,mBAAA,CAAAI,IAAA,WAAAmT,UAAA;cAAA,kBAAAA,UAAA,CAAAjT,IAAA,GAAAiT,UAAA,CAAAhT,IAAA;gBAAA;kBAAAgT,UAAA,CAAAhT,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAA6Y,UAAA,CAAA5S,IAAA;cAAA;YAAA,GAAA2S,SAAA;UAAA,CACjE,GAAC;QAAA;UAEF5T,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE,gBAAgB;YACtBiM,MAAM,EAAEpO,MAAM,CAACmB,gBAAgB,CAAC;cAAEC,OAAO,EAAEpB,MAAM,CAAC8T,GAAG,CAACC,MAAM;YAAE,CAAC;UACjE,CAAC,CACH,CAAC;UACDrS,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAuR,UAAA,CAAA1S,IAAA;MAAA;IAAA,GAAAwS,SAAA;EAAA,CAC1B,GAAC;EAEF9T,EAAE,CAAC,8EAA8E,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAyT,UAAA;IAAA,IAAAtS,WAAA,EAAAuS,aAAA,EAAAlU,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAAwT,UAAA;MAAA,kBAAAA,UAAA,CAAAtT,IAAA,GAAAsT,UAAA,CAAArT,IAAA;QAAA;UACjF/F,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,uBAAuB;YAC3BmF,OAAO,EAAE,MAAM;YACfI,IAAI,EAAErI,eAAe,CAACyK,IAAI;YAC1BL,IAAI,EAAE;cAAEtH,EAAE,EAAE,GAAG;cAAEsF,IAAI,EAAE;YAAM,CAAC;YAC9BsC,IAAI,EAAE,IAAIC,IAAI,CAAC;UACjB,CAAC,EACD;YACE7H,EAAE,EAAE,0BAA0B;YAC9BmF,OAAO,EAAE,OAAO;YAChBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBmH,OAAO,EAAE,IAAI;YACboI,eAAe,EAAE;UACnB,CAAC,CACF;UACD5Y,mBAAmB,CAACH,iBAAiB,CAAC;YAAEC,OAAO,EAAE,KAAK;YAAE+Y,MAAM,EAAE;UAAiB,CAAC,CAAC;UACnF9Y,WAAW,CAACF,iBAAiB,CAAC;YAAEC,OAAO,EAAE,KAAK;YAAE+Y,MAAM,EAAE;UAAQ,CAAC,CAAC;UAC5D5R,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UAAAmS,aAAA,GAEtCnb,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAkU,aAAA,CAANlU,MAAM;UAAAmU,UAAA,CAAArT,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA4T,UAAA;YAAA,OAAA7T,mBAAA,CAAAI,IAAA,WAAA0T,UAAA;cAAA,kBAAAA,UAAA,CAAAxT,IAAA,GAAAwT,UAAA,CAAAvT,IAAA;gBAAA;kBAAAuT,UAAA,CAAAvT,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAACkE,YAAY,CAACrJ,iBAAiB,CAACE,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAoZ,UAAA,CAAAnT,IAAA;cAAA;YAAA,GAAAkT,SAAA;UAAA,CACjE,GAAC;QAAA;UAEFnU,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE;UACR,CAAC,CACH,CAAC;UACDT,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAA8R,UAAA,CAAAjT,IAAA;MAAA;IAAA,GAAA+S,SAAA;EAAA,CAC1B,GAAC;EAEFrU,EAAE,CAAC,4EAA4E,eAAAU,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA8T,UAAA;IAAA,IAAA3S,WAAA,EAAA4S,aAAA,EAAAvU,MAAA;IAAA,OAAAO,mBAAA,CAAAI,IAAA,WAAA6T,UAAA;MAAA,kBAAAA,UAAA,CAAA3T,IAAA,GAAA2T,UAAA,CAAA1T,IAAA;QAAA;UAC/EvH,UAAU,CAACmG,GAAG,CAAC,WAAW,CAAC;UAC3BtF,uBAAuB,CAACG,iBAAiB,CAAC;YAAEC,OAAO,EAAE,KAAK;YAAE+Y,MAAM,EAAE;UAAQ,CAAC,CAAC;UACxE5R,WAAW,GAAGtH,IAAI,CAACyH,KAAK,CAACC,QAAQ,EAAE,eAAe,CAAC;UACzDhH,iBAAiB,CAACE,QAAQ,GAAG,CAC3B;YACEiB,EAAE,EAAE,oBAAoB;YACxBmF,OAAO,EAAE,UAAU;YACnBI,IAAI,EAAErI,eAAe,CAAC4K,SAAS;YAC/BR,IAAI,EAAE;cAAEtH,EAAE,EAAE,WAAW;cAAEsF,IAAI,EAAE;YAAO,CAAC;YACvCsC,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC;YAChBuB,QAAQ,EAAE;cACRC,UAAU,EAAE,WAAW;cACvBC,eAAe,EAAE,CAAC;gBAAEC,SAAS,EAAE,cAAc;gBAAEC,SAAS,EAAE,WAAW;gBAAEC,SAAS,EAAE,CAAC;cAAE,CAAC;YACxF;UACF,CAAC,CACF;UAAA4O,aAAA,GAEkBxb,UAAU,CAC3B;YAAA,OACEe,cAAc,CAAC;cACbgG,MAAM,EAAE,WAAW;cACnBC,MAAM,EAAE,CAAC9G,SAAS;YACpB,CAAC,CAAC;UAAA,GACJ;YAAE+E,OAAO,EAAPA;UAAQ,CACZ,CAAC,EAPOgC,MAAM,GAAAuU,aAAA,CAANvU,MAAM;UAAAwU,UAAA,CAAA1T,IAAA;UAAA,OASRhI,GAAG,cAAAwH,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAiU,UAAA;YAAA,OAAAlU,mBAAA,CAAAI,IAAA,WAAA+T,UAAA;cAAA,kBAAAA,UAAA,CAAA7T,IAAA,GAAA6T,UAAA,CAAA5T,IAAA;gBAAA;kBAAA4T,UAAA,CAAA5T,IAAA;kBAAA,OACFd,MAAM,CAACE,OAAO,CAAC6F,sBAAsB,CAAC,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC;gBAAA;gBAAA;kBAAA,OAAA2O,UAAA,CAAAxT,IAAA;cAAA;YAAA,GAAAuT,SAAA;UAAA,CACzE,GAAC;QAAA;UAEFxU,MAAM,CAAC7F,uBAAuB,CAAC,CAAC+H,gBAAgB,CAAC,CAAC;UAClDlC,MAAM,CAAC0B,WAAW,CAAC,CAACR,oBAAoB,CACtClB,MAAM,CAACmB,gBAAgB,CAAC;YACtBgB,IAAI,EAAE;UACR,CAAC,CACH,CAAC;UACDT,WAAW,CAACU,WAAW,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAmS,UAAA,CAAAtT,IAAA;MAAA;IAAA,GAAAoT,SAAA;EAAA,CAC1B,GAAC;AACJ,CAAC,CAAC","ignoreList":[]}