This is page 44 of 60. Use http://codebase.md/hangwin/mcp-chrome?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .github
│ └── workflows
│ └── build-release.yml
├── .gitignore
├── .husky
│ ├── commit-msg
│ └── pre-commit
├── .prettierignore
├── .prettierrc.json
├── .vscode
│ └── extensions.json
├── app
│ ├── chrome-extension
│ │ ├── _locales
│ │ │ ├── de
│ │ │ │ └── messages.json
│ │ │ ├── en
│ │ │ │ └── messages.json
│ │ │ ├── ja
│ │ │ │ └── messages.json
│ │ │ ├── ko
│ │ │ │ └── messages.json
│ │ │ ├── zh_CN
│ │ │ │ └── messages.json
│ │ │ └── zh_TW
│ │ │ └── messages.json
│ │ ├── .env.example
│ │ ├── assets
│ │ │ └── vue.svg
│ │ ├── common
│ │ │ ├── agent-models.ts
│ │ │ ├── constants.ts
│ │ │ ├── element-marker-types.ts
│ │ │ ├── message-types.ts
│ │ │ ├── node-types.ts
│ │ │ ├── rr-v3-keepalive-protocol.ts
│ │ │ ├── step-types.ts
│ │ │ ├── tool-handler.ts
│ │ │ └── web-editor-types.ts
│ │ ├── entrypoints
│ │ │ ├── background
│ │ │ │ ├── element-marker
│ │ │ │ │ ├── element-marker-storage.ts
│ │ │ │ │ └── index.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── keepalive-manager.ts
│ │ │ │ ├── native-host.ts
│ │ │ │ ├── quick-panel
│ │ │ │ │ ├── agent-handler.ts
│ │ │ │ │ ├── commands.ts
│ │ │ │ │ └── tabs-handler.ts
│ │ │ │ ├── record-replay
│ │ │ │ │ ├── actions
│ │ │ │ │ │ ├── adapter.ts
│ │ │ │ │ │ ├── handlers
│ │ │ │ │ │ │ ├── assert.ts
│ │ │ │ │ │ │ ├── click.ts
│ │ │ │ │ │ │ ├── common.ts
│ │ │ │ │ │ │ ├── control-flow.ts
│ │ │ │ │ │ │ ├── delay.ts
│ │ │ │ │ │ │ ├── dom.ts
│ │ │ │ │ │ │ ├── drag.ts
│ │ │ │ │ │ │ ├── extract.ts
│ │ │ │ │ │ │ ├── fill.ts
│ │ │ │ │ │ │ ├── http.ts
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── key.ts
│ │ │ │ │ │ │ ├── navigate.ts
│ │ │ │ │ │ │ ├── screenshot.ts
│ │ │ │ │ │ │ ├── script.ts
│ │ │ │ │ │ │ ├── scroll.ts
│ │ │ │ │ │ │ ├── tabs.ts
│ │ │ │ │ │ │ └── wait.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── registry.ts
│ │ │ │ │ │ └── types.ts
│ │ │ │ │ ├── engine
│ │ │ │ │ │ ├── constants.ts
│ │ │ │ │ │ ├── execution-mode.ts
│ │ │ │ │ │ ├── logging
│ │ │ │ │ │ │ └── run-logger.ts
│ │ │ │ │ │ ├── plugins
│ │ │ │ │ │ │ ├── breakpoint.ts
│ │ │ │ │ │ │ ├── manager.ts
│ │ │ │ │ │ │ └── types.ts
│ │ │ │ │ │ ├── policies
│ │ │ │ │ │ │ ├── retry.ts
│ │ │ │ │ │ │ └── wait.ts
│ │ │ │ │ │ ├── runners
│ │ │ │ │ │ │ ├── after-script-queue.ts
│ │ │ │ │ │ │ ├── control-flow-runner.ts
│ │ │ │ │ │ │ ├── step-executor.ts
│ │ │ │ │ │ │ ├── step-runner.ts
│ │ │ │ │ │ │ └── subflow-runner.ts
│ │ │ │ │ │ ├── scheduler.ts
│ │ │ │ │ │ ├── state-manager.ts
│ │ │ │ │ │ └── utils
│ │ │ │ │ │ └── expression.ts
│ │ │ │ │ ├── flow-runner.ts
│ │ │ │ │ ├── flow-store.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── legacy-types.ts
│ │ │ │ │ ├── nodes
│ │ │ │ │ │ ├── assert.ts
│ │ │ │ │ │ ├── click.ts
│ │ │ │ │ │ ├── conditional.ts
│ │ │ │ │ │ ├── download-screenshot-attr-event-frame-loop.ts
│ │ │ │ │ │ ├── drag.ts
│ │ │ │ │ │ ├── execute-flow.ts
│ │ │ │ │ │ ├── extract.ts
│ │ │ │ │ │ ├── fill.ts
│ │ │ │ │ │ ├── http.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── key.ts
│ │ │ │ │ │ ├── loops.ts
│ │ │ │ │ │ ├── navigate.ts
│ │ │ │ │ │ ├── script.ts
│ │ │ │ │ │ ├── scroll.ts
│ │ │ │ │ │ ├── tabs.ts
│ │ │ │ │ │ ├── types.ts
│ │ │ │ │ │ └── wait.ts
│ │ │ │ │ ├── recording
│ │ │ │ │ │ ├── browser-event-listener.ts
│ │ │ │ │ │ ├── content-injection.ts
│ │ │ │ │ │ ├── content-message-handler.ts
│ │ │ │ │ │ ├── flow-builder.ts
│ │ │ │ │ │ ├── recorder-manager.ts
│ │ │ │ │ │ └── session-manager.ts
│ │ │ │ │ ├── rr-utils.ts
│ │ │ │ │ ├── selector-engine.ts
│ │ │ │ │ ├── storage
│ │ │ │ │ │ └── indexeddb-manager.ts
│ │ │ │ │ ├── trigger-store.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── record-replay-v3
│ │ │ │ │ ├── bootstrap.ts
│ │ │ │ │ ├── domain
│ │ │ │ │ │ ├── debug.ts
│ │ │ │ │ │ ├── errors.ts
│ │ │ │ │ │ ├── events.ts
│ │ │ │ │ │ ├── flow.ts
│ │ │ │ │ │ ├── ids.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── json.ts
│ │ │ │ │ │ ├── policy.ts
│ │ │ │ │ │ ├── triggers.ts
│ │ │ │ │ │ └── variables.ts
│ │ │ │ │ ├── engine
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── keepalive
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ └── offscreen-keepalive.ts
│ │ │ │ │ │ ├── kernel
│ │ │ │ │ │ │ ├── artifacts.ts
│ │ │ │ │ │ │ ├── breakpoints.ts
│ │ │ │ │ │ │ ├── debug-controller.ts
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── kernel.ts
│ │ │ │ │ │ │ ├── recovery-kernel.ts
│ │ │ │ │ │ │ ├── runner.ts
│ │ │ │ │ │ │ └── traversal.ts
│ │ │ │ │ │ ├── plugins
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── register-v2-replay-nodes.ts
│ │ │ │ │ │ │ ├── registry.ts
│ │ │ │ │ │ │ ├── types.ts
│ │ │ │ │ │ │ └── v2-action-adapter.ts
│ │ │ │ │ │ ├── queue
│ │ │ │ │ │ │ ├── enqueue-run.ts
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── leasing.ts
│ │ │ │ │ │ │ ├── queue.ts
│ │ │ │ │ │ │ └── scheduler.ts
│ │ │ │ │ │ ├── recovery
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ └── recovery-coordinator.ts
│ │ │ │ │ │ ├── storage
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ └── storage-port.ts
│ │ │ │ │ │ ├── transport
│ │ │ │ │ │ │ ├── events-bus.ts
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── rpc-server.ts
│ │ │ │ │ │ │ └── rpc.ts
│ │ │ │ │ │ └── triggers
│ │ │ │ │ │ ├── command-trigger.ts
│ │ │ │ │ │ ├── context-menu-trigger.ts
│ │ │ │ │ │ ├── cron-trigger.ts
│ │ │ │ │ │ ├── dom-trigger.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── interval-trigger.ts
│ │ │ │ │ │ ├── manual-trigger.ts
│ │ │ │ │ │ ├── once-trigger.ts
│ │ │ │ │ │ ├── trigger-handler.ts
│ │ │ │ │ │ ├── trigger-manager.ts
│ │ │ │ │ │ └── url-trigger.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── storage
│ │ │ │ │ ├── db.ts
│ │ │ │ │ ├── events.ts
│ │ │ │ │ ├── flows.ts
│ │ │ │ │ ├── import
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── v2-reader.ts
│ │ │ │ │ │ └── v2-to-v3.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── persistent-vars.ts
│ │ │ │ │ ├── queue.ts
│ │ │ │ │ ├── runs.ts
│ │ │ │ │ └── triggers.ts
│ │ │ │ ├── semantic-similarity.ts
│ │ │ │ ├── storage-manager.ts
│ │ │ │ ├── tools
│ │ │ │ │ ├── base-browser.ts
│ │ │ │ │ ├── browser
│ │ │ │ │ │ ├── bookmark.ts
│ │ │ │ │ │ ├── common.ts
│ │ │ │ │ │ ├── computer.ts
│ │ │ │ │ │ ├── console-buffer.ts
│ │ │ │ │ │ ├── console.ts
│ │ │ │ │ │ ├── dialog.ts
│ │ │ │ │ │ ├── download.ts
│ │ │ │ │ │ ├── element-picker.ts
│ │ │ │ │ │ ├── file-upload.ts
│ │ │ │ │ │ ├── gif-auto-capture.ts
│ │ │ │ │ │ ├── gif-enhanced-renderer.ts
│ │ │ │ │ │ ├── gif-recorder.ts
│ │ │ │ │ │ ├── history.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── inject-script.ts
│ │ │ │ │ │ ├── interaction.ts
│ │ │ │ │ │ ├── javascript.ts
│ │ │ │ │ │ ├── keyboard.ts
│ │ │ │ │ │ ├── network-capture-debugger.ts
│ │ │ │ │ │ ├── network-capture-web-request.ts
│ │ │ │ │ │ ├── network-capture.ts
│ │ │ │ │ │ ├── network-request.ts
│ │ │ │ │ │ ├── performance.ts
│ │ │ │ │ │ ├── read-page.ts
│ │ │ │ │ │ ├── screenshot.ts
│ │ │ │ │ │ ├── userscript.ts
│ │ │ │ │ │ ├── vector-search.ts
│ │ │ │ │ │ ├── web-fetcher.ts
│ │ │ │ │ │ └── window.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── record-replay.ts
│ │ │ │ ├── utils
│ │ │ │ │ └── sidepanel.ts
│ │ │ │ └── web-editor
│ │ │ │ └── index.ts
│ │ │ ├── builder
│ │ │ │ ├── App.vue
│ │ │ │ ├── index.html
│ │ │ │ └── main.ts
│ │ │ ├── content.ts
│ │ │ ├── element-picker.content.ts
│ │ │ ├── offscreen
│ │ │ │ ├── gif-encoder.ts
│ │ │ │ ├── index.html
│ │ │ │ ├── main.ts
│ │ │ │ └── rr-keepalive.ts
│ │ │ ├── options
│ │ │ │ ├── App.vue
│ │ │ │ ├── index.html
│ │ │ │ └── main.ts
│ │ │ ├── popup
│ │ │ │ ├── App.vue
│ │ │ │ ├── components
│ │ │ │ │ ├── builder
│ │ │ │ │ │ ├── components
│ │ │ │ │ │ │ ├── Canvas.vue
│ │ │ │ │ │ │ ├── EdgePropertyPanel.vue
│ │ │ │ │ │ │ ├── KeyValueEditor.vue
│ │ │ │ │ │ │ ├── nodes
│ │ │ │ │ │ │ │ ├── node-util.ts
│ │ │ │ │ │ │ │ ├── NodeCard.vue
│ │ │ │ │ │ │ │ └── NodeIf.vue
│ │ │ │ │ │ │ ├── properties
│ │ │ │ │ │ │ │ ├── PropertyAssert.vue
│ │ │ │ │ │ │ │ ├── PropertyClick.vue
│ │ │ │ │ │ │ │ ├── PropertyCloseTab.vue
│ │ │ │ │ │ │ │ ├── PropertyDelay.vue
│ │ │ │ │ │ │ │ ├── PropertyDrag.vue
│ │ │ │ │ │ │ │ ├── PropertyExecuteFlow.vue
│ │ │ │ │ │ │ │ ├── PropertyExtract.vue
│ │ │ │ │ │ │ │ ├── PropertyFill.vue
│ │ │ │ │ │ │ │ ├── PropertyForeach.vue
│ │ │ │ │ │ │ │ ├── PropertyFormRenderer.vue
│ │ │ │ │ │ │ │ ├── PropertyFromSpec.vue
│ │ │ │ │ │ │ │ ├── PropertyHandleDownload.vue
│ │ │ │ │ │ │ │ ├── PropertyHttp.vue
│ │ │ │ │ │ │ │ ├── PropertyIf.vue
│ │ │ │ │ │ │ │ ├── PropertyKey.vue
│ │ │ │ │ │ │ │ ├── PropertyLoopElements.vue
│ │ │ │ │ │ │ │ ├── PropertyNavigate.vue
│ │ │ │ │ │ │ │ ├── PropertyOpenTab.vue
│ │ │ │ │ │ │ │ ├── PropertyScreenshot.vue
│ │ │ │ │ │ │ │ ├── PropertyScript.vue
│ │ │ │ │ │ │ │ ├── PropertyScroll.vue
│ │ │ │ │ │ │ │ ├── PropertySetAttribute.vue
│ │ │ │ │ │ │ │ ├── PropertySwitchFrame.vue
│ │ │ │ │ │ │ │ ├── PropertySwitchTab.vue
│ │ │ │ │ │ │ │ ├── PropertyTrigger.vue
│ │ │ │ │ │ │ │ ├── PropertyTriggerEvent.vue
│ │ │ │ │ │ │ │ ├── PropertyWait.vue
│ │ │ │ │ │ │ │ ├── PropertyWhile.vue
│ │ │ │ │ │ │ │ └── SelectorEditor.vue
│ │ │ │ │ │ │ ├── PropertyPanel.vue
│ │ │ │ │ │ │ ├── Sidebar.vue
│ │ │ │ │ │ │ └── TriggerPanel.vue
│ │ │ │ │ │ ├── model
│ │ │ │ │ │ │ ├── form-widget-registry.ts
│ │ │ │ │ │ │ ├── node-spec-registry.ts
│ │ │ │ │ │ │ ├── node-spec.ts
│ │ │ │ │ │ │ ├── node-specs-builtin.ts
│ │ │ │ │ │ │ ├── toast.ts
│ │ │ │ │ │ │ ├── transforms.ts
│ │ │ │ │ │ │ ├── ui-nodes.ts
│ │ │ │ │ │ │ ├── validation.ts
│ │ │ │ │ │ │ └── variables.ts
│ │ │ │ │ │ ├── store
│ │ │ │ │ │ │ └── useBuilderStore.ts
│ │ │ │ │ │ └── widgets
│ │ │ │ │ │ ├── FieldCode.vue
│ │ │ │ │ │ ├── FieldDuration.vue
│ │ │ │ │ │ ├── FieldExpression.vue
│ │ │ │ │ │ ├── FieldKeySequence.vue
│ │ │ │ │ │ ├── FieldSelector.vue
│ │ │ │ │ │ ├── FieldTargetLocator.vue
│ │ │ │ │ │ └── VarInput.vue
│ │ │ │ │ ├── ConfirmDialog.vue
│ │ │ │ │ ├── ElementMarkerManagement.vue
│ │ │ │ │ ├── icons
│ │ │ │ │ │ ├── BoltIcon.vue
│ │ │ │ │ │ ├── CheckIcon.vue
│ │ │ │ │ │ ├── DatabaseIcon.vue
│ │ │ │ │ │ ├── DocumentIcon.vue
│ │ │ │ │ │ ├── EditIcon.vue
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── MarkerIcon.vue
│ │ │ │ │ │ ├── RecordIcon.vue
│ │ │ │ │ │ ├── RefreshIcon.vue
│ │ │ │ │ │ ├── StopIcon.vue
│ │ │ │ │ │ ├── TabIcon.vue
│ │ │ │ │ │ ├── TrashIcon.vue
│ │ │ │ │ │ ├── VectorIcon.vue
│ │ │ │ │ │ └── WorkflowIcon.vue
│ │ │ │ │ ├── LocalModelPage.vue
│ │ │ │ │ ├── ModelCacheManagement.vue
│ │ │ │ │ ├── ProgressIndicator.vue
│ │ │ │ │ └── ScheduleDialog.vue
│ │ │ │ ├── index.html
│ │ │ │ ├── main.ts
│ │ │ │ └── style.css
│ │ │ ├── quick-panel.content.ts
│ │ │ ├── shared
│ │ │ │ ├── composables
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── useRRV3Rpc.ts
│ │ │ │ └── utils
│ │ │ │ ├── index.ts
│ │ │ │ └── rr-flow-convert.ts
│ │ │ ├── sidepanel
│ │ │ │ ├── App.vue
│ │ │ │ ├── components
│ │ │ │ │ ├── agent
│ │ │ │ │ │ ├── AttachmentPreview.vue
│ │ │ │ │ │ ├── ChatInput.vue
│ │ │ │ │ │ ├── CliSettings.vue
│ │ │ │ │ │ ├── ConnectionStatus.vue
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── MessageItem.vue
│ │ │ │ │ │ ├── MessageList.vue
│ │ │ │ │ │ ├── ProjectCreateForm.vue
│ │ │ │ │ │ └── ProjectSelector.vue
│ │ │ │ │ ├── agent-chat
│ │ │ │ │ │ ├── AgentChatShell.vue
│ │ │ │ │ │ ├── AgentComposer.vue
│ │ │ │ │ │ ├── AgentConversation.vue
│ │ │ │ │ │ ├── AgentOpenProjectMenu.vue
│ │ │ │ │ │ ├── AgentProjectMenu.vue
│ │ │ │ │ │ ├── AgentRequestThread.vue
│ │ │ │ │ │ ├── AgentSessionListItem.vue
│ │ │ │ │ │ ├── AgentSessionMenu.vue
│ │ │ │ │ │ ├── AgentSessionSettingsPanel.vue
│ │ │ │ │ │ ├── AgentSessionsView.vue
│ │ │ │ │ │ ├── AgentSettingsMenu.vue
│ │ │ │ │ │ ├── AgentTimeline.vue
│ │ │ │ │ │ ├── AgentTimelineItem.vue
│ │ │ │ │ │ ├── AgentTopBar.vue
│ │ │ │ │ │ ├── ApplyMessageChip.vue
│ │ │ │ │ │ ├── AttachmentCachePanel.vue
│ │ │ │ │ │ ├── ComposerDrawer.vue
│ │ │ │ │ │ ├── ElementChip.vue
│ │ │ │ │ │ ├── FakeCaretOverlay.vue
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── SelectionChip.vue
│ │ │ │ │ │ ├── timeline
│ │ │ │ │ │ │ ├── markstream-thinking.ts
│ │ │ │ │ │ │ ├── ThinkingNode.vue
│ │ │ │ │ │ │ ├── TimelineNarrativeStep.vue
│ │ │ │ │ │ │ ├── TimelineStatusStep.vue
│ │ │ │ │ │ │ ├── TimelineToolCallStep.vue
│ │ │ │ │ │ │ ├── TimelineToolResultCardStep.vue
│ │ │ │ │ │ │ └── TimelineUserPromptStep.vue
│ │ │ │ │ │ └── WebEditorChanges.vue
│ │ │ │ │ ├── AgentChat.vue
│ │ │ │ │ ├── rr-v3
│ │ │ │ │ │ └── DebuggerPanel.vue
│ │ │ │ │ ├── SidepanelNavigator.vue
│ │ │ │ │ └── workflows
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── WorkflowListItem.vue
│ │ │ │ │ └── WorkflowsView.vue
│ │ │ │ ├── composables
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── useAgentChat.ts
│ │ │ │ │ ├── useAgentChatViewRoute.ts
│ │ │ │ │ ├── useAgentInputPreferences.ts
│ │ │ │ │ ├── useAgentProjects.ts
│ │ │ │ │ ├── useAgentServer.ts
│ │ │ │ │ ├── useAgentSessions.ts
│ │ │ │ │ ├── useAgentTheme.ts
│ │ │ │ │ ├── useAgentThreads.ts
│ │ │ │ │ ├── useAttachments.ts
│ │ │ │ │ ├── useFakeCaret.ts
│ │ │ │ │ ├── useFloatingDrag.ts
│ │ │ │ │ ├── useOpenProjectPreference.ts
│ │ │ │ │ ├── useRRV3Debugger.ts
│ │ │ │ │ ├── useRRV3Rpc.ts
│ │ │ │ │ ├── useTextareaAutoResize.ts
│ │ │ │ │ ├── useWebEditorTxState.ts
│ │ │ │ │ └── useWorkflowsV3.ts
│ │ │ │ ├── index.html
│ │ │ │ ├── main.ts
│ │ │ │ ├── styles
│ │ │ │ │ └── agent-chat.css
│ │ │ │ └── utils
│ │ │ │ └── loading-texts.ts
│ │ │ ├── styles
│ │ │ │ └── tailwind.css
│ │ │ ├── web-editor-v2
│ │ │ │ ├── attr-ui-refactor.md
│ │ │ │ ├── constants.ts
│ │ │ │ ├── core
│ │ │ │ │ ├── css-compare.ts
│ │ │ │ │ ├── cssom-styles-collector.ts
│ │ │ │ │ ├── debug-source.ts
│ │ │ │ │ ├── design-tokens
│ │ │ │ │ │ ├── design-tokens-service.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── token-detector.ts
│ │ │ │ │ │ ├── token-resolver.ts
│ │ │ │ │ │ └── types.ts
│ │ │ │ │ ├── editor.ts
│ │ │ │ │ ├── element-key.ts
│ │ │ │ │ ├── event-controller.ts
│ │ │ │ │ ├── execution-tracker.ts
│ │ │ │ │ ├── hmr-consistency.ts
│ │ │ │ │ ├── locator.ts
│ │ │ │ │ ├── message-listener.ts
│ │ │ │ │ ├── payload-builder.ts
│ │ │ │ │ ├── perf-monitor.ts
│ │ │ │ │ ├── position-tracker.ts
│ │ │ │ │ ├── props-bridge.ts
│ │ │ │ │ ├── snap-engine.ts
│ │ │ │ │ ├── transaction-aggregator.ts
│ │ │ │ │ └── transaction-manager.ts
│ │ │ │ ├── drag
│ │ │ │ │ └── drag-reorder-controller.ts
│ │ │ │ ├── overlay
│ │ │ │ │ ├── canvas-overlay.ts
│ │ │ │ │ └── handles-controller.ts
│ │ │ │ ├── selection
│ │ │ │ │ └── selection-engine.ts
│ │ │ │ ├── ui
│ │ │ │ │ ├── breadcrumbs.ts
│ │ │ │ │ ├── floating-drag.ts
│ │ │ │ │ ├── icons.ts
│ │ │ │ │ ├── property-panel
│ │ │ │ │ │ ├── class-editor.ts
│ │ │ │ │ │ ├── components
│ │ │ │ │ │ │ ├── alignment-grid.ts
│ │ │ │ │ │ │ ├── icon-button-group.ts
│ │ │ │ │ │ │ ├── input-container.ts
│ │ │ │ │ │ │ ├── slider-input.ts
│ │ │ │ │ │ │ └── token-pill.ts
│ │ │ │ │ │ ├── components-tree.ts
│ │ │ │ │ │ ├── controls
│ │ │ │ │ │ │ ├── appearance-control.ts
│ │ │ │ │ │ │ ├── background-control.ts
│ │ │ │ │ │ │ ├── border-control.ts
│ │ │ │ │ │ │ ├── color-field.ts
│ │ │ │ │ │ │ ├── css-helpers.ts
│ │ │ │ │ │ │ ├── effects-control.ts
│ │ │ │ │ │ │ ├── gradient-control.ts
│ │ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ │ ├── layout-control.ts
│ │ │ │ │ │ │ ├── number-stepping.ts
│ │ │ │ │ │ │ ├── position-control.ts
│ │ │ │ │ │ │ ├── size-control.ts
│ │ │ │ │ │ │ ├── spacing-control.ts
│ │ │ │ │ │ │ ├── token-picker.ts
│ │ │ │ │ │ │ └── typography-control.ts
│ │ │ │ │ │ ├── css-defaults.ts
│ │ │ │ │ │ ├── css-panel.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ ├── property-panel.ts
│ │ │ │ │ │ ├── props-panel.ts
│ │ │ │ │ │ └── types.ts
│ │ │ │ │ ├── shadow-host.ts
│ │ │ │ │ └── toolbar.ts
│ │ │ │ └── utils
│ │ │ │ └── disposables.ts
│ │ │ ├── web-editor-v2.ts
│ │ │ └── welcome
│ │ │ ├── App.vue
│ │ │ ├── index.html
│ │ │ └── main.ts
│ │ ├── env.d.ts
│ │ ├── eslint.config.js
│ │ ├── inject-scripts
│ │ │ ├── accessibility-tree-helper.js
│ │ │ ├── click-helper.js
│ │ │ ├── dom-observer.js
│ │ │ ├── element-marker.js
│ │ │ ├── element-picker.js
│ │ │ ├── fill-helper.js
│ │ │ ├── inject-bridge.js
│ │ │ ├── interactive-elements-helper.js
│ │ │ ├── keyboard-helper.js
│ │ │ ├── network-helper.js
│ │ │ ├── props-agent.js
│ │ │ ├── recorder.js
│ │ │ ├── screenshot-helper.js
│ │ │ ├── wait-helper.js
│ │ │ ├── web-editor.js
│ │ │ └── web-fetcher-helper.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── public
│ │ │ ├── icon
│ │ │ │ ├── 128.png
│ │ │ │ ├── 16.png
│ │ │ │ ├── 32.png
│ │ │ │ ├── 48.png
│ │ │ │ └── 96.png
│ │ │ ├── libs
│ │ │ │ └── ort.min.js
│ │ │ └── wxt.svg
│ │ ├── README.md
│ │ ├── shared
│ │ │ ├── element-picker
│ │ │ │ ├── controller.ts
│ │ │ │ └── index.ts
│ │ │ ├── quick-panel
│ │ │ │ ├── core
│ │ │ │ │ ├── agent-bridge.ts
│ │ │ │ │ ├── search-engine.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── providers
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── tabs-provider.ts
│ │ │ │ └── ui
│ │ │ │ ├── ai-chat-panel.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── markdown-renderer.ts
│ │ │ │ ├── message-renderer.ts
│ │ │ │ ├── panel-shell.ts
│ │ │ │ ├── quick-entries.ts
│ │ │ │ ├── search-input.ts
│ │ │ │ ├── shadow-host.ts
│ │ │ │ └── styles.ts
│ │ │ └── selector
│ │ │ ├── dom-path.ts
│ │ │ ├── fingerprint.ts
│ │ │ ├── generator.ts
│ │ │ ├── index.ts
│ │ │ ├── locator.ts
│ │ │ ├── shadow-dom.ts
│ │ │ ├── stability.ts
│ │ │ ├── strategies
│ │ │ │ ├── anchor-relpath.ts
│ │ │ │ ├── aria.ts
│ │ │ │ ├── css-path.ts
│ │ │ │ ├── css-unique.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── testid.ts
│ │ │ │ └── text.ts
│ │ │ └── types.ts
│ │ ├── tailwind.config.ts
│ │ ├── tests
│ │ │ ├── __mocks__
│ │ │ │ └── hnswlib-wasm-static.ts
│ │ │ ├── record-replay
│ │ │ │ ├── _test-helpers.ts
│ │ │ │ ├── adapter-policy.contract.test.ts
│ │ │ │ ├── flow-store-strip-steps.contract.test.ts
│ │ │ │ ├── high-risk-actions.integration.test.ts
│ │ │ │ ├── hybrid-actions.integration.test.ts
│ │ │ │ ├── script-control-flow.integration.test.ts
│ │ │ │ ├── session-dag-sync.contract.test.ts
│ │ │ │ ├── step-executor.contract.test.ts
│ │ │ │ └── tab-cursor.integration.test.ts
│ │ │ ├── record-replay-v3
│ │ │ │ ├── command-trigger.test.ts
│ │ │ │ ├── context-menu-trigger.test.ts
│ │ │ │ ├── cron-trigger.test.ts
│ │ │ │ ├── debugger.contract.test.ts
│ │ │ │ ├── dom-trigger.test.ts
│ │ │ │ ├── e2e.integration.test.ts
│ │ │ │ ├── events.contract.test.ts
│ │ │ │ ├── interval-trigger.test.ts
│ │ │ │ ├── manual-trigger.test.ts
│ │ │ │ ├── once-trigger.test.ts
│ │ │ │ ├── queue.contract.test.ts
│ │ │ │ ├── recovery.test.ts
│ │ │ │ ├── rpc-api.test.ts
│ │ │ │ ├── runner.onError.contract.test.ts
│ │ │ │ ├── scheduler-integration.test.ts
│ │ │ │ ├── scheduler.test.ts
│ │ │ │ ├── spec-smoke.test.ts
│ │ │ │ ├── trigger-manager.test.ts
│ │ │ │ ├── triggers.test.ts
│ │ │ │ ├── url-trigger.test.ts
│ │ │ │ ├── v2-action-adapter.test.ts
│ │ │ │ ├── v2-adapter-integration.test.ts
│ │ │ │ ├── v2-to-v3-conversion.test.ts
│ │ │ │ └── v3-e2e-harness.ts
│ │ │ ├── vitest.setup.ts
│ │ │ └── web-editor-v2
│ │ │ ├── design-tokens.test.ts
│ │ │ ├── drag-reorder-controller.test.ts
│ │ │ ├── event-controller.test.ts
│ │ │ ├── locator.test.ts
│ │ │ ├── property-panel-live-sync.test.ts
│ │ │ ├── selection-engine.test.ts
│ │ │ ├── snap-engine.test.ts
│ │ │ └── test-utils
│ │ │ └── dom.ts
│ │ ├── tsconfig.json
│ │ ├── types
│ │ │ ├── gifenc.d.ts
│ │ │ └── icons.d.ts
│ │ ├── utils
│ │ │ ├── cdp-session-manager.ts
│ │ │ ├── content-indexer.ts
│ │ │ ├── i18n.ts
│ │ │ ├── image-utils.ts
│ │ │ ├── indexeddb-client.ts
│ │ │ ├── lru-cache.ts
│ │ │ ├── model-cache-manager.ts
│ │ │ ├── offscreen-manager.ts
│ │ │ ├── output-sanitizer.ts
│ │ │ ├── screenshot-context.ts
│ │ │ ├── semantic-similarity-engine.ts
│ │ │ ├── simd-math-engine.ts
│ │ │ ├── text-chunker.ts
│ │ │ └── vector-database.ts
│ │ ├── vitest.config.ts
│ │ ├── workers
│ │ │ ├── ort-wasm-simd-threaded.jsep.mjs
│ │ │ ├── ort-wasm-simd-threaded.jsep.wasm
│ │ │ ├── ort-wasm-simd-threaded.mjs
│ │ │ ├── ort-wasm-simd-threaded.wasm
│ │ │ ├── simd_math_bg.wasm
│ │ │ ├── simd_math.js
│ │ │ └── similarity.worker.js
│ │ └── wxt.config.ts
│ └── native-server
│ ├── .npmignore
│ ├── debug.sh
│ ├── install.md
│ ├── jest.config.js
│ ├── package.json
│ ├── README.md
│ ├── src
│ │ ├── agent
│ │ │ ├── attachment-service.ts
│ │ │ ├── ccr-detector.ts
│ │ │ ├── chat-service.ts
│ │ │ ├── db
│ │ │ │ ├── client.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── schema.ts
│ │ │ ├── directory-picker.ts
│ │ │ ├── engines
│ │ │ │ ├── claude.ts
│ │ │ │ ├── codex.ts
│ │ │ │ └── types.ts
│ │ │ ├── message-service.ts
│ │ │ ├── open-project.ts
│ │ │ ├── project-service.ts
│ │ │ ├── project-types.ts
│ │ │ ├── session-service.ts
│ │ │ ├── storage.ts
│ │ │ ├── stream-manager.ts
│ │ │ ├── tool-bridge.ts
│ │ │ └── types.ts
│ │ ├── cli.ts
│ │ ├── constant
│ │ │ └── index.ts
│ │ ├── file-handler.ts
│ │ ├── index.ts
│ │ ├── mcp
│ │ │ ├── mcp-server-stdio.ts
│ │ │ ├── mcp-server.ts
│ │ │ ├── register-tools.ts
│ │ │ └── stdio-config.json
│ │ ├── native-messaging-host.ts
│ │ ├── scripts
│ │ │ ├── browser-config.ts
│ │ │ ├── build.ts
│ │ │ ├── constant.ts
│ │ │ ├── doctor.ts
│ │ │ ├── postinstall.ts
│ │ │ ├── register-dev.ts
│ │ │ ├── register.ts
│ │ │ ├── report.ts
│ │ │ ├── run_host.bat
│ │ │ ├── run_host.sh
│ │ │ └── utils.ts
│ │ ├── server
│ │ │ ├── index.ts
│ │ │ ├── routes
│ │ │ │ ├── agent.ts
│ │ │ │ └── index.ts
│ │ │ └── server.test.ts
│ │ ├── shims
│ │ │ └── devtools.d.ts
│ │ ├── trace-analyzer.ts
│ │ ├── types
│ │ │ └── devtools-frontend.d.ts
│ │ └── util
│ │ └── logger.ts
│ └── tsconfig.json
├── commitlint.config.cjs
├── docs
│ ├── ARCHITECTURE_zh.md
│ ├── ARCHITECTURE.md
│ ├── CHANGELOG.md
│ ├── CONTRIBUTING_zh.md
│ ├── CONTRIBUTING.md
│ ├── ISSUE.md
│ ├── mcp-cli-config.md
│ ├── TOOLS_zh.md
│ ├── TOOLS.md
│ ├── TROUBLESHOOTING_zh.md
│ ├── TROUBLESHOOTING.md
│ ├── VisualEditor_zh.md
│ ├── VisualEditor.md
│ └── WINDOWS_INSTALL_zh.md
├── eslint.config.js
├── LICENSE
├── package.json
├── packages
│ ├── shared
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── agent-types.ts
│ │ │ ├── constants.ts
│ │ │ ├── index.ts
│ │ │ ├── labels.ts
│ │ │ ├── node-spec-registry.ts
│ │ │ ├── node-spec.ts
│ │ │ ├── node-specs-builtin.ts
│ │ │ ├── rr-graph.ts
│ │ │ ├── step-types.ts
│ │ │ ├── tools.ts
│ │ │ └── types.ts
│ │ └── tsconfig.json
│ └── wasm-simd
│ ├── .gitignore
│ ├── BUILD.md
│ ├── Cargo.toml
│ ├── package.json
│ ├── README.md
│ └── src
│ └── lib.rs
├── pnpm-lock.yaml
├── pnpm-workspace.yaml
├── prompt
│ ├── content-analize.md
│ ├── excalidraw-prompt.md
│ └── modify-web.md
├── README_zh.md
├── README.md
└── releases
├── chrome-extension
│ └── latest
│ └── chrome-mcp-server-lastest.zip
└── README.md
```
# Files
--------------------------------------------------------------------------------
/app/chrome-extension/workers/ort-wasm-simd-threaded.jsep.mjs:
--------------------------------------------------------------------------------
```
1 | var ortWasmThreaded = (() => {
2 | var _scriptName = import.meta.url;
3 |
4 | return (
5 | async function(moduleArg = {}) {
6 | var moduleRtn;
7 |
8 | var e=moduleArg,aa,ca,da=new Promise((a,b)=>{aa=a;ca=b}),ea="object"==typeof window,k="undefined"!=typeof WorkerGlobalScope,n="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node&&"renderer"!=process.type,q=k&&self.name?.startsWith("em-pthread");if(n){const {createRequire:a}=await import("module");var require=a(import.meta.url),fa=require("worker_threads");global.Worker=fa.Worker;q=(k=!fa.pc)&&"em-pthread"==fa.workerData}
9 | e.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(e.Fb||(e.Fb=new Map)).set(a,b)};e.unmountExternalData=()=>{delete e.Fb};var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,qc:!0})).buffer.constructor;
10 | const ha=a=>async(...b)=>{try{if(e.Gb)throw Error("Session already started");const c=e.Gb={ec:b[0],errors:[]},d=await a(...b);if(e.Gb!==c)throw Error("Session mismatch");e.Kb?.flush();const f=c.errors;if(0<f.length){let g=await Promise.all(f);g=g.filter(h=>h);if(0<g.length)throw Error(g.join("\n"));}return d}finally{e.Gb=null}};
11 | e.jsepInit=(a,b)=>{if("webgpu"===a){[e.Kb,e.Vb,e.Zb,e.Lb,e.Yb,e.kb,e.$b,e.bc,e.Wb,e.Xb,e.ac]=b;const c=e.Kb;e.jsepRegisterBuffer=(d,f,g,h)=>c.registerBuffer(d,f,g,h);e.jsepGetBuffer=d=>c.getBuffer(d);e.jsepCreateDownloader=(d,f,g)=>c.createDownloader(d,f,g);e.jsepOnCreateSession=d=>{c.onCreateSession(d)};e.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};e.jsepOnRunStart=d=>c.onRunStart(d);e.cc=(d,f)=>{c.upload(d,f)}}else if("webnn"===a){const c=b[0];[e.oc,e.Ob,e.webnnEnsureTensor,e.Pb,e.webnnDownloadTensor]=
12 | b.slice(1);e.webnnReleaseTensorId=e.Ob;e.webnnUploadTensor=e.Pb;e.webnnOnRunStart=d=>c.onRunStart(d);e.webnnOnRunEnd=c.onRunEnd.bind(c);e.webnnRegisterMLContext=(d,f)=>{c.registerMLContext(d,f)};e.webnnOnReleaseSession=d=>{c.onReleaseSession(d)};e.webnnCreateMLTensorDownloader=(d,f)=>c.createMLTensorDownloader(d,f);e.webnnRegisterMLTensor=(d,f,g,h)=>c.registerMLTensor(d,f,g,h);e.webnnCreateMLContext=d=>c.createMLContext(d);e.webnnRegisterMLConstant=(d,f,g,h,l,m)=>c.registerMLConstant(d,f,g,h,l,e.Fb,
13 | m);e.webnnRegisterGraphInput=c.registerGraphInput.bind(c);e.webnnIsGraphInput=c.isGraphInput.bind(c);e.webnnRegisterGraphOutput=c.registerGraphOutput.bind(c);e.webnnIsGraphOutput=c.isGraphOutput.bind(c);e.webnnCreateTemporaryTensor=c.createTemporaryTensor.bind(c);e.webnnIsGraphInputOutputTypeSupported=c.isGraphInputOutputTypeSupported.bind(c)}};
14 | let ja=()=>{const a=(b,c,d)=>(...f)=>{const g=t,h=c?.();f=b(...f);const l=c?.();h!==l&&(b=l,d(h),c=d=null);return t!=g?ia():f};(b=>{for(const c of b)e[c]=a(e[c],()=>e[c],d=>e[c]=d)})(["_OrtAppendExecutionProvider","_OrtCreateSession","_OrtRun","_OrtRunWithBinding","_OrtBindInput"]);"undefined"!==typeof ha&&(e._OrtRun=ha(e._OrtRun),e._OrtRunWithBinding=ha(e._OrtRunWithBinding));ja=void 0};e.asyncInit=()=>{ja?.()};var ka=Object.assign({},e),la="./this.program",ma=(a,b)=>{throw b;},v="",na,oa;
15 | if(n){var fs=require("fs"),pa=require("path");import.meta.url.startsWith("data:")||(v=pa.dirname(require("url").fileURLToPath(import.meta.url))+"/");oa=a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a)};na=async a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a,void 0)};!e.thisProgram&&1<process.argv.length&&(la=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);ma=(a,b)=>{process.exitCode=a;throw b;}}else if(ea||k)k?v=self.location.href:"undefined"!=typeof document&&
16 | document.currentScript&&(v=document.currentScript.src),_scriptName&&(v=_scriptName),v.startsWith("blob:")?v="":v=v.slice(0,v.replace(/[?#].*/,"").lastIndexOf("/")+1),n||(k&&(oa=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=async a=>{if(qa(a))return new Promise((c,d)=>{var f=new XMLHttpRequest;f.open("GET",a,!0);f.responseType="arraybuffer";f.onload=()=>{200==f.status||0==f.status&&f.response?c(f.response):d(f.status)};
17 | f.onerror=d;f.send(null)});var b=await fetch(a,{credentials:"same-origin"});if(b.ok)return b.arrayBuffer();throw Error(b.status+" : "+b.url);});var ra=console.log.bind(console),sa=console.error.bind(console);n&&(ra=(...a)=>fs.writeSync(1,a.join(" ")+"\n"),sa=(...a)=>fs.writeSync(2,a.join(" ")+"\n"));var ta=ra,x=sa;Object.assign(e,ka);ka=null;var ua=e.wasmBinary,z,va,A=!1,wa,B,xa,ya,za,Aa,Ba,Ca,C,Da,Ea,qa=a=>a.startsWith("file://");function D(){z.buffer!=B.buffer&&E();return B}
18 | function F(){z.buffer!=B.buffer&&E();return xa}function G(){z.buffer!=B.buffer&&E();return ya}function Fa(){z.buffer!=B.buffer&&E();return za}function H(){z.buffer!=B.buffer&&E();return Aa}function I(){z.buffer!=B.buffer&&E();return Ba}function Ga(){z.buffer!=B.buffer&&E();return Ca}function J(){z.buffer!=B.buffer&&E();return Ea}
19 | if(q){var Ha;if(n){var Ia=fa.parentPort;Ia.on("message",b=>onmessage({data:b}));Object.assign(globalThis,{self:global,postMessage:b=>Ia.postMessage(b)})}var Ja=!1;x=function(...b){b=b.join(" ");n?fs.writeSync(2,b+"\n"):console.error(b)};self.alert=function(...b){postMessage({Cb:"alert",text:b.join(" "),jc:Ka()})};self.onunhandledrejection=b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.Cb;if("load"===d){let f=[];self.onmessage=g=>f.push(g);self.startWorker=()=>{postMessage({Cb:"loaded"});
20 | for(let g of f)a(g);self.onmessage=a};for(const g of c.Sb)if(!e[g]||e[g].proxy)e[g]=(...h)=>{postMessage({Cb:"callHandler",Rb:g,args:h})},"print"==g&&(ta=e[g]),"printErr"==g&&(x=e[g]);z=c.lc;E();Ha(c.mc)}else if("run"===d){La(c.Bb);Ma(c.Bb,0,0,1,0,0);Na();Oa(c.Bb);Ja||(Pa(),Ja=!0);try{Qa(c.hc,c.Ib)}catch(f){if("unwind"!=f)throw f;}}else"setimmediate"!==c.target&&("checkMailbox"===d?Ja&&Ra():d&&(x(`worker: received unknown command ${d}`),x(c)))}catch(f){throw Sa(),f;}}self.onmessage=a}
21 | function E(){var a=z.buffer;e.HEAP8=B=new Int8Array(a);e.HEAP16=ya=new Int16Array(a);e.HEAPU8=xa=new Uint8Array(a);e.HEAPU16=za=new Uint16Array(a);e.HEAP32=Aa=new Int32Array(a);e.HEAPU32=Ba=new Uint32Array(a);e.HEAPF32=Ca=new Float32Array(a);e.HEAPF64=Ea=new Float64Array(a);e.HEAP64=C=new BigInt64Array(a);e.HEAPU64=Da=new BigUint64Array(a)}q||(z=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0}),E());function Ta(){q?startWorker(e):K.Da()}var Ua=0,Va=null;
22 | function Wa(){Ua--;if(0==Ua&&Va){var a=Va;Va=null;a()}}function L(a){a="Aborted("+a+")";x(a);A=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");ca(a);throw a;}var Xa;async function Ya(a){if(!ua)try{var b=await na(a);return new Uint8Array(b)}catch{}if(a==Xa&&ua)a=new Uint8Array(ua);else if(oa)a=oa(a);else throw"both async and sync fetching of the wasm failed";return a}
23 | async function Za(a,b){try{var c=await Ya(a);return await WebAssembly.instantiate(c,b)}catch(d){x(`failed to asynchronously prepare wasm: ${d}`),L(d)}}async function $a(a){var b=Xa;if(!ua&&"function"==typeof WebAssembly.instantiateStreaming&&!qa(b)&&!n)try{var c=fetch(b,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(c,a)}catch(d){x(`wasm streaming compile failed: ${d}`),x("falling back to ArrayBuffer instantiation")}return Za(b,a)}
24 | function ab(){bb={L:cb,Aa:db,b:eb,$:fb,A:gb,pa:hb,X:ib,Z:jb,qa:kb,na:lb,ga:mb,ma:nb,J:ob,Y:pb,V:qb,oa:rb,W:sb,va:tb,E:ub,Q:vb,O:wb,D:xb,v:yb,r:zb,P:Ab,z:Bb,R:Cb,ja:Db,T:Eb,aa:Fb,M:Gb,F:Hb,ia:Oa,sa:Ib,t:Jb,Ca:Kb,w:Lb,o:Mb,m:Nb,c:Ob,Ba:Pb,n:Qb,j:Rb,u:Sb,p:Tb,f:Ub,s:Vb,l:Wb,e:Xb,k:Yb,h:Zb,g:$b,d:ac,da:bc,ea:cc,fa:dc,ba:ec,ca:fc,N:gc,xa:hc,ua:ic,i:jc,C:kc,G:lc,ta:mc,x:nc,ra:oc,U:pc,q:qc,y:rc,K:sc,S:tc,za:uc,ya:vc,ka:wc,la:xc,_:yc,B:zc,I:Ac,ha:Bc,H:Cc,a:z,wa:Dc};return{a:bb}}
25 | var Ec={840156:(a,b,c,d,f)=>{if("undefined"==typeof e||!e.Fb)return 1;a=M(Number(a>>>0));a.startsWith("./")&&(a=a.substring(2));a=e.Fb.get(a);if(!a)return 2;b=Number(b>>>0);c=Number(c>>>0);d=Number(d>>>0);if(b+c>a.byteLength)return 3;try{const g=a.subarray(b,b+c);switch(f){case 0:F().set(g,d>>>0);break;case 1:e.nc?e.nc(d,g):e.cc(d,g);break;default:return 4}return 0}catch{return 4}},840980:(a,b,c)=>{e.Pb(a,F().subarray(b>>>0,b+c>>>0))},841044:()=>e.oc(),841086:a=>{e.Ob(a)},841123:()=>{e.Wb()},841154:()=>
26 | {e.Xb()},841183:()=>{e.ac()},841208:a=>e.Vb(a),841241:a=>e.Zb(a),841273:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c),!0)},841336:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c))},841393:()=>"undefined"!==typeof wasmOffsetConverter,841450:a=>{e.kb("Abs",a,void 0)},841501:a=>{e.kb("Neg",a,void 0)},841552:a=>{e.kb("Floor",a,void 0)},841605:a=>{e.kb("Ceil",a,void 0)},841657:a=>{e.kb("Reciprocal",a,void 0)},841715:a=>{e.kb("Sqrt",a,void 0)},841767:a=>{e.kb("Exp",a,void 0)},841818:a=>{e.kb("Erf",a,void 0)},
27 | 841869:a=>{e.kb("Sigmoid",a,void 0)},841924:(a,b,c)=>{e.kb("HardSigmoid",a,{alpha:b,beta:c})},842003:a=>{e.kb("Log",a,void 0)},842054:a=>{e.kb("Sin",a,void 0)},842105:a=>{e.kb("Cos",a,void 0)},842156:a=>{e.kb("Tan",a,void 0)},842207:a=>{e.kb("Asin",a,void 0)},842259:a=>{e.kb("Acos",a,void 0)},842311:a=>{e.kb("Atan",a,void 0)},842363:a=>{e.kb("Sinh",a,void 0)},842415:a=>{e.kb("Cosh",a,void 0)},842467:a=>{e.kb("Asinh",a,void 0)},842520:a=>{e.kb("Acosh",a,void 0)},842573:a=>{e.kb("Atanh",a,void 0)},
28 | 842626:a=>{e.kb("Tanh",a,void 0)},842678:a=>{e.kb("Not",a,void 0)},842729:(a,b,c)=>{e.kb("Clip",a,{min:b,max:c})},842798:a=>{e.kb("Clip",a,void 0)},842850:(a,b)=>{e.kb("Elu",a,{alpha:b})},842908:a=>{e.kb("Gelu",a,void 0)},842960:a=>{e.kb("Relu",a,void 0)},843012:(a,b)=>{e.kb("LeakyRelu",a,{alpha:b})},843076:(a,b)=>{e.kb("ThresholdedRelu",a,{alpha:b})},843146:(a,b)=>{e.kb("Cast",a,{to:b})},843204:a=>{e.kb("Add",a,void 0)},843255:a=>{e.kb("Sub",a,void 0)},843306:a=>{e.kb("Mul",a,void 0)},843357:a=>
29 | {e.kb("Div",a,void 0)},843408:a=>{e.kb("Pow",a,void 0)},843459:a=>{e.kb("Equal",a,void 0)},843512:a=>{e.kb("Greater",a,void 0)},843567:a=>{e.kb("GreaterOrEqual",a,void 0)},843629:a=>{e.kb("Less",a,void 0)},843681:a=>{e.kb("LessOrEqual",a,void 0)},843740:(a,b,c,d,f)=>{e.kb("ReduceMean",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},843915:(a,b,c,d,f)=>{e.kb("ReduceMax",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
30 | 0,Number(f)>>>0)):[]})},844089:(a,b,c,d,f)=>{e.kb("ReduceMin",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844263:(a,b,c,d,f)=>{e.kb("ReduceProd",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844438:(a,b,c,d,f)=>{e.kb("ReduceSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844612:(a,b,c,d,f)=>{e.kb("ReduceL1",a,{keepDims:!!b,
31 | noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844785:(a,b,c,d,f)=>{e.kb("ReduceL2",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844958:(a,b,c,d,f)=>{e.kb("ReduceLogSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845135:(a,b,c,d,f)=>{e.kb("ReduceSumSquare",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
32 | 0,Number(f)>>>0)):[]})},845315:(a,b,c,d,f)=>{e.kb("ReduceLogSumExp",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845495:a=>{e.kb("Where",a,void 0)},845548:(a,b,c)=>{e.kb("Transpose",a,{perm:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[]})},845672:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845805:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845938:(a,
33 | b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},846371:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>
34 | 0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},847032:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",
35 | autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},847465:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+
36 | 2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},848126:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848217:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,
37 | count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},848696:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848787:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,
38 | storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849266:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849353:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?
39 | Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849828:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849915:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>
40 | 0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},850390:(a,b,c,d,f)=>{e.kb("Gemm",a,{alpha:b,beta:c,transA:d,transB:f})},850494:a=>{e.kb("MatMul",a,void 0)},850548:(a,b,c,d)=>{e.kb("ArgMax",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850656:(a,b,c,d)=>{e.kb("ArgMin",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850764:(a,
41 | b)=>{e.kb("Softmax",a,{axis:b})},850827:(a,b)=>{e.kb("Concat",a,{axis:b})},850887:(a,b,c,d,f)=>{e.kb("Split",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},851043:a=>{e.kb("Expand",a,void 0)},851097:(a,b)=>{e.kb("Gather",a,{axis:Number(b)})},851168:(a,b)=>{e.kb("GatherElements",a,{axis:Number(b)})},851247:(a,b)=>{e.kb("GatherND",a,{batch_dims:Number(b)})},851326:(a,b,c,d,f,g,h,l,m,p,r)=>{e.kb("Resize",a,{antialias:b,axes:c?Array.from(H().subarray(Number(c)>>>
42 | 0,Number(d)>>>0)):[],coordinateTransformMode:M(f),cubicCoeffA:g,excludeOutside:h,extrapolationValue:l,keepAspectRatioPolicy:M(m),mode:M(p),nearestMode:M(r)})},851688:(a,b,c,d,f,g,h)=>{e.kb("Slice",a,{starts:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[],ends:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[],axes:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[]})},851952:a=>{e.kb("Tile",a,void 0)},852004:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":
43 | "NCHW"})},852118:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":"NCHW"})},852232:a=>{e.kb("Range",a,void 0)},852285:(a,b)=>{e.kb("Einsum",a,{equation:M(b)})},852366:(a,b,c,d,f)=>{e.kb("Pad",a,{mode:b,value:c,pads:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},852509:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,trainingMode:!!d,format:g?"NHWC":"NCHW"})},852678:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,
44 | trainingMode:!!d,format:g?"NHWC":"NCHW"})},852847:(a,b,c)=>{e.kb("CumSum",a,{exclusive:Number(b),reverse:Number(c)})},852944:(a,b,c)=>{e.kb("DequantizeLinear",a,{axis:b,blockSize:c})},853034:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853204:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853374:(a,b)=>{e.kb("ScatterND",a,{reduction:M(b)})},853459:(a,b,c,d,f,g,h,l,m)=>{e.kb("Attention",
45 | a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g,qkvHiddenSizes:h?Array.from(H().subarray(Number(l)>>>0,Number(l)+h>>>0)):[],pastPresentShareBuffer:!!m})},853731:a=>{e.kb("BiasAdd",a,void 0)},853786:a=>{e.kb("BiasSplitGelu",a,void 0)},853847:a=>{e.kb("FastGelu",a,void 0)},853903:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba,Wd)=>{e.kb("Conv",a,{format:u?"NHWC":"NCHW",auto_pad:b,dilations:c?Array.from(H().subarray(Number(c)>>>0,Number(d)>>>0)):[],group:f,kernel_shape:g?Array.from(H().subarray(Number(g)>>>
46 | 0,Number(h)>>>0)):[],pads:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],strides:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],w_is_const:()=>!!D()[Number(w)>>>0],activation:M(y),activation_params:ba?Array.from(Ga().subarray(Number(ba)>>>0,Number(Wd)>>>0)):[]})},854487:a=>{e.kb("Gelu",a,void 0)},854539:(a,b,c,d,f,g,h,l,m)=>{e.kb("GroupQueryAttention",a,{numHeads:b,kvNumHeads:c,scale:d,softcap:f,doRotary:g,rotaryInterleaved:h,smoothSoftmax:l,localWindowSize:m})},854756:(a,
47 | b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854867:(a,b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854978:(a,b,c,d,f,g)=>{e.kb("MatMulNBits",a,{k:b,n:c,accuracyLevel:d,bits:f,blockSize:g})},855105:(a,b,c,d,f,g)=>{e.kb("MultiHeadAttention",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g})},855264:(a,b)=>{e.kb("QuickGelu",a,{alpha:b})},855328:(a,b,c,d,f)=>{e.kb("RotaryEmbedding",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,
48 | scale:f})},855467:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855569:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855671:(a,b,c,d)=>{e.kb("GatherBlockQuantized",a,{gatherAxis:b,quantizeAxis:c,blockSize:d})},855792:a=>{e.$b(a)},855826:(a,b)=>e.bc(Number(a),Number(b),e.Gb.ec,e.Gb.errors)};function db(a,b,c){return Fc(async()=>{await e.Yb(Number(a),Number(b),Number(c))})}function cb(){return"undefined"!==typeof wasmOffsetConverter}
49 | class Gc{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
50 | var Hc=a=>{a.terminate();a.onmessage=()=>{}},Ic=[],Mc=a=>{0==N.length&&(Jc(),Kc(N[0]));var b=N.pop();if(!b)return 6;Lc.push(b);O[a.Bb]=b;b.Bb=a.Bb;var c={Cb:"run",hc:a.fc,Ib:a.Ib,Bb:a.Bb};n&&b.unref();b.postMessage(c,a.Nb);return 0},P=0,Q=(a,b,...c)=>{for(var d=2*c.length,f=Nc(),g=Oc(8*d),h=g>>>3,l=0;l<c.length;l++){var m=c[l];"bigint"==typeof m?(C[h+2*l]=1n,C[h+2*l+1]=m):(C[h+2*l]=0n,J()[h+2*l+1>>>0]=m)}a=Pc(a,0,d,g,b);Qc(f);return a};
51 | function Dc(a){if(q)return Q(0,1,a);wa=a;if(!(0<P)){for(var b of Lc)Hc(b);for(b of N)Hc(b);N=[];Lc=[];O={};A=!0}ma(a,new Gc(a))}function Rc(a){if(q)return Q(1,0,a);yc(a)}var yc=a=>{wa=a;if(q)throw Rc(a),"unwind";Dc(a)},N=[],Lc=[],Sc=[],O={};function Tc(){for(var a=e.numThreads-1;a--;)Jc();Ic.unshift(()=>{Ua++;Uc(()=>Wa())})}var Wc=a=>{var b=a.Bb;delete O[b];N.push(a);Lc.splice(Lc.indexOf(a),1);a.Bb=0;Vc(b)};function Na(){Sc.forEach(a=>a())}
52 | var Kc=a=>new Promise(b=>{a.onmessage=g=>{g=g.data;var h=g.Cb;if(g.Hb&&g.Hb!=Ka()){var l=O[g.Hb];l?l.postMessage(g,g.Nb):x(`Internal error! Worker sent a message "${h}" to target pthread ${g.Hb}, but that thread no longer exists!`)}else if("checkMailbox"===h)Ra();else if("spawnThread"===h)Mc(g);else if("cleanupThread"===h)Wc(O[g.ic]);else if("loaded"===h)a.loaded=!0,n&&!a.Bb&&a.unref(),b(a);else if("alert"===h)alert(`Thread ${g.jc}: ${g.text}`);else if("setimmediate"===g.target)a.postMessage(g);else if("callHandler"===
53 | h)e[g.Rb](...g.args);else h&&x(`worker sent an unknown command ${h}`)};a.onerror=g=>{x(`${"worker sent an error!"} ${g.filename}:${g.lineno}: ${g.message}`);throw g;};n&&(a.on("message",g=>a.onmessage({data:g})),a.on("error",g=>a.onerror(g)));var c=[],d=[],f;for(f of d)e.propertyIsEnumerable(f)&&c.push(f);a.postMessage({Cb:"load",Sb:c,lc:z,mc:va})});function Uc(a){q?a():Promise.all(N.map(Kc)).then(a)}
54 | function Jc(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});N.push(a)}var La=a=>{E();var b=I()[a+52>>>2>>>0];a=I()[a+56>>>2>>>0];Xc(b,b-a);Qc(b)},Qa=(a,b)=>{P=0;a=Yc(a,b);0<P?wa=a:Zc(a)};class $c{constructor(a){this.Jb=a-24}}var ad=0,bd=0;function eb(a,b,c){a>>>=0;var d=new $c(a);b>>>=0;c>>>=0;I()[d.Jb+16>>>2>>>0]=0;I()[d.Jb+4>>>2>>>0]=b;I()[d.Jb+8>>>2>>>0]=c;ad=a;bd++;throw ad;}
55 | function cd(a,b,c,d){return q?Q(2,1,a,b,c,d):fb(a,b,c,d)}function fb(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if("undefined"==typeof SharedArrayBuffer)return 6;var f=[];if(q&&0===f.length)return cd(a,b,c,d);a={fc:c,Bb:a,Ib:d,Nb:f};return q?(a.Cb="spawnThread",postMessage(a,f),0):Mc(a)}
56 | var dd="undefined"!=typeof TextDecoder?new TextDecoder:void 0,ed=(a,b=0,c=NaN)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&dd)return dd.decode(a.buffer instanceof ArrayBuffer?a.subarray(b,c):a.slice(b,c));for(d="";b<c;){var f=a[b++];if(f&128){var g=a[b++]&63;if(192==(f&224))d+=String.fromCharCode((f&31)<<6|g);else{var h=a[b++]&63;f=224==(f&240)?(f&15)<<12|g<<6|h:(f&7)<<18|g<<12|h<<6|a[b++]&63;65536>f?d+=String.fromCharCode(f):(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|
57 | f&1023))}}else d+=String.fromCharCode(f)}return d},M=(a,b)=>(a>>>=0)?ed(F(),a,b):"";function gb(a,b,c){return q?Q(3,1,a,b,c):0}function hb(a,b){if(q)return Q(4,1,a,b)}
58 | var fd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},gd=(a,b,c)=>{var d=F();b>>>=0;if(0<c){var f=b;c=b+c-1;for(var g=0;g<a.length;++g){var h=a.charCodeAt(g);if(55296<=h&&57343>=h){var l=a.charCodeAt(++g);h=65536+((h&1023)<<10)|l&1023}if(127>=h){if(b>=c)break;d[b++>>>0]=h}else{if(2047>=h){if(b+1>=c)break;d[b++>>>0]=192|h>>6}else{if(65535>=h){if(b+2>=c)break;d[b++>>>0]=224|h>>12}else{if(b+3>=c)break;d[b++>>>0]=240|h>>18;
59 | d[b++>>>0]=128|h>>12&63}d[b++>>>0]=128|h>>6&63}d[b++>>>0]=128|h&63}}d[b>>>0]=0;a=b-f}else a=0;return a};function ib(a,b){if(q)return Q(5,1,a,b)}function jb(a,b,c){if(q)return Q(6,1,a,b,c)}function kb(a,b,c){return q?Q(7,1,a,b,c):0}function lb(a,b){if(q)return Q(8,1,a,b)}function mb(a,b,c){if(q)return Q(9,1,a,b,c)}function nb(a,b,c,d){if(q)return Q(10,1,a,b,c,d)}function ob(a,b,c,d){if(q)return Q(11,1,a,b,c,d)}function pb(a,b,c,d){if(q)return Q(12,1,a,b,c,d)}function qb(a){if(q)return Q(13,1,a)}
60 | function rb(a,b){if(q)return Q(14,1,a,b)}function sb(a,b,c){if(q)return Q(15,1,a,b,c)}var tb=()=>L(""),hd,R=a=>{for(var b="";F()[a>>>0];)b+=hd[F()[a++>>>0]];return b},jd={},kd={},ld={},S;function md(a,b,c={}){var d=b.name;if(!a)throw new S(`type "${d}" must have a positive integer typeid pointer`);if(kd.hasOwnProperty(a)){if(c.Tb)return;throw new S(`Cannot register type '${d}' twice`);}kd[a]=b;delete ld[a];jd.hasOwnProperty(a)&&(b=jd[a],delete jd[a],b.forEach(f=>f()))}
61 | function T(a,b,c={}){return md(a,b,c)}var nd=(a,b,c)=>{switch(b){case 1:return c?d=>D()[d>>>0]:d=>F()[d>>>0];case 2:return c?d=>G()[d>>>1>>>0]:d=>Fa()[d>>>1>>>0];case 4:return c?d=>H()[d>>>2>>>0]:d=>I()[d>>>2>>>0];case 8:return c?d=>C[d>>>3]:d=>Da[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}};
62 | function ub(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:function(d,f){if("bigint"!=typeof f&&"number"!=typeof f)throw null===f?f="null":(d=typeof f,f="object"===d||"array"===d||"function"===d?f.toString():""+f),new TypeError(`Cannot convert "${f}" to ${this.name}`);"number"==typeof f&&(f=BigInt(f));return f},Db:U,readValueFromPointer:nd(b,c,-1==b.indexOf("u")),Eb:null})}var U=8;
63 | function vb(a,b,c,d){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(f){return!!f},toWireType:function(f,g){return g?c:d},Db:U,readValueFromPointer:function(f){return this.fromWireType(F()[f>>>0])},Eb:null})}var od=[],V=[];function Ob(a){a>>>=0;9<a&&0===--V[a+1]&&(V[a]=void 0,od.push(a))}
64 | var W=a=>{if(!a)throw new S("Cannot use deleted val. handle = "+a);return V[a]},X=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=od.pop()||V.length;V[b]=a;V[b+1]=1;return b}};function pd(a){return this.fromWireType(I()[a>>>2>>>0])}var qd={name:"emscripten::val",fromWireType:a=>{var b=W(a);Ob(a);return b},toWireType:(a,b)=>X(b),Db:U,readValueFromPointer:pd,Eb:null};function wb(a){return T(a>>>0,qd)}
65 | var rd=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(Ga()[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(J()[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}};function xb(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:(d,f)=>f,Db:U,readValueFromPointer:rd(b,c),Eb:null})}
66 | function yb(a,b,c,d,f){a>>>=0;c>>>=0;b=R(b>>>0);-1===f&&(f=4294967295);f=l=>l;if(0===d){var g=32-8*c;f=l=>l<<g>>>g}var h=b.includes("unsigned")?function(l,m){return m>>>0}:function(l,m){return m};T(a,{name:b,fromWireType:f,toWireType:h,Db:U,readValueFromPointer:nd(b,c,0!==d),Eb:null})}
67 | function zb(a,b,c){function d(g){var h=I()[g>>>2>>>0];g=I()[g+4>>>2>>>0];return new f(D().buffer,g,h)}a>>>=0;var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=R(c>>>0);T(a,{name:c,fromWireType:d,Db:U,readValueFromPointer:d},{Tb:!0})}
68 | function Ab(a,b){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(c){for(var d=I()[c>>>2>>>0],f=c+4,g,h=f,l=0;l<=d;++l){var m=f+l;if(l==d||0==F()[m>>>0])h=M(h,m-h),void 0===g?g=h:(g+=String.fromCharCode(0),g+=h),h=m+1}Y(c);return g},toWireType:function(c,d){d instanceof ArrayBuffer&&(d=new Uint8Array(d));var f="string"==typeof d;if(!(f||d instanceof Uint8Array||d instanceof Uint8ClampedArray||d instanceof Int8Array))throw new S("Cannot pass non-string to std::string");var g=f?fd(d):d.length;var h=
69 | sd(4+g+1),l=h+4;I()[h>>>2>>>0]=g;if(f)gd(d,l,g+1);else if(f)for(f=0;f<g;++f){var m=d.charCodeAt(f);if(255<m)throw Y(h),new S("String has UTF-16 code units that do not fit in 8 bits");F()[l+f>>>0]=m}else for(f=0;f<g;++f)F()[l+f>>>0]=d[f];null!==c&&c.push(Y,h);return h},Db:U,readValueFromPointer:pd,Eb(c){Y(c)}})}
70 | var td="undefined"!=typeof TextDecoder?new TextDecoder("utf-16le"):void 0,ud=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&Fa()[c>>>0];)++c;c<<=1;if(32<c-a&&td)return td.decode(F().slice(a,c));c="";for(d=0;!(d>=b/2);++d){var f=G()[a+2*d>>>1>>>0];if(0==f)break;c+=String.fromCharCode(f)}return c},vd=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var f=0;f<c;++f){var g=a.charCodeAt(f);G()[b>>>1>>>0]=g;b+=2}G()[b>>>1>>>0]=0;return b-d},wd=a=>2*a.length,xd=(a,b)=>{for(var c=
71 | 0,d="";!(c>=b/4);){var f=H()[a+4*c>>>2>>>0];if(0==f)break;++c;65536<=f?(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|f&1023)):d+=String.fromCharCode(f)}return d},yd=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var h=a.charCodeAt(++f);g=65536+((g&1023)<<10)|h&1023}H()[b>>>2>>>0]=g;b+=4;if(b+4>c)break}H()[b>>>2>>>0]=0;return b-d},zd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=
72 | d&&++c;b+=4}return b};
73 | function Bb(a,b,c){a>>>=0;b>>>=0;c>>>=0;c=R(c);if(2===b){var d=ud;var f=vd;var g=wd;var h=l=>Fa()[l>>>1>>>0]}else 4===b&&(d=xd,f=yd,g=zd,h=l=>I()[l>>>2>>>0]);T(a,{name:c,fromWireType:l=>{for(var m=I()[l>>>2>>>0],p,r=l+4,u=0;u<=m;++u){var w=l+4+u*b;if(u==m||0==h(w))r=d(r,w-r),void 0===p?p=r:(p+=String.fromCharCode(0),p+=r),r=w+b}Y(l);return p},toWireType:(l,m)=>{if("string"!=typeof m)throw new S(`Cannot pass non-string to C++ string type ${c}`);var p=g(m),r=sd(4+p+b);I()[r>>>2>>>0]=p/b;f(m,r+4,p+b);
74 | null!==l&&l.push(Y,r);return r},Db:U,readValueFromPointer:pd,Eb(l){Y(l)}})}function Cb(a,b){a>>>=0;b=R(b>>>0);T(a,{Ub:!0,name:b,Db:0,fromWireType:()=>{},toWireType:()=>{}})}function Db(a){Ma(a>>>0,!k,1,!ea,131072,!1);Na()}var Ad=a=>{if(!A)try{if(a(),!(0<P))try{q?Zc(wa):yc(wa)}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}};
75 | function Oa(a){a>>>=0;"function"===typeof Atomics.kc&&(Atomics.kc(H(),a>>>2,a).value.then(Ra),a+=128,Atomics.store(H(),a>>>2,1))}var Ra=()=>{var a=Ka();a&&(Oa(a),Ad(Bd))};function Eb(a,b){a>>>=0;a==b>>>0?setTimeout(Ra):q?postMessage({Hb:a,Cb:"checkMailbox"}):(a=O[a])&&a.postMessage({Cb:"checkMailbox"})}var Cd=[];function Fb(a,b,c,d,f){b>>>=0;d/=2;Cd.length=d;c=f>>>0>>>3;for(f=0;f<d;f++)Cd[f]=C[c+2*f]?C[c+2*f+1]:J()[c+2*f+1>>>0];return(b?Ec[b]:Dd[a])(...Cd)}var Gb=()=>{P=0};
76 | function Hb(a){a>>>=0;q?postMessage({Cb:"cleanupThread",ic:a}):Wc(O[a])}function Ib(a){n&&O[a>>>0].ref()}var Fd=(a,b)=>{var c=kd[a];if(void 0===c)throw a=Ed(a),c=R(a),Y(a),new S(`${b} has unknown type ${c}`);return c},Gd=(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I()[b>>>2>>>0]=X(d));return a};function Jb(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return Gd(b,c,a)}function Kb(a,b){b>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return b.toWireType(null,a)}var Hd=a=>{try{a()}catch(b){L(b)}};
77 | function Id(){var a=K,b={};for(let [c,d]of Object.entries(a))b[c]="function"==typeof d?(...f)=>{Jd.push(c);try{return d(...f)}finally{A||(Jd.pop(),t&&1===Z&&0===Jd.length&&(Z=0,P+=1,Hd(Kd),"undefined"!=typeof Fibers&&Fibers.sc()))}}:d;return b}var Z=0,t=null,Ld=0,Jd=[],Md={},Nd={},Od=0,Pd=null,Qd=[];function ia(){return new Promise((a,b)=>{Pd={resolve:a,reject:b}})}
78 | function Rd(){var a=sd(65548),b=a+12;I()[a>>>2>>>0]=b;I()[a+4>>>2>>>0]=b+65536;b=Jd[0];var c=Md[b];void 0===c&&(c=Od++,Md[b]=c,Nd[c]=b);b=c;H()[a+8>>>2>>>0]=b;return a}function Sd(){var a=H()[t+8>>>2>>>0];a=K[Nd[a]];--P;return a()}
79 | function Td(a){if(!A){if(0===Z){var b=!1,c=!1;a((d=0)=>{if(!A&&(Ld=d,b=!0,c)){Z=2;Hd(()=>Ud(t));"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.resume();d=!1;try{var f=Sd()}catch(l){f=l,d=!0}var g=!1;if(!t){var h=Pd;h&&(Pd=null,(d?h.reject:h.resolve)(f),g=!0)}if(d&&!g)throw f;}});c=!0;b||(Z=1,t=Rd(),"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.pause(),Hd(()=>Vd(t)))}else 2===Z?(Z=0,Hd(Xd),Y(t),t=null,Qd.forEach(Ad)):L(`invalid state: ${Z}`);return Ld}}
80 | function Fc(a){return Td(b=>{a().then(b)})}function Lb(a){a>>>=0;return Fc(async()=>{var b=await W(a);return X(b)})}var Yd=[];function Mb(a,b,c,d){c>>>=0;d>>>=0;a=Yd[a>>>0];b=W(b>>>0);return a(null,b,c,d)}var Zd={},$d=a=>{var b=Zd[a];return void 0===b?R(a):b};function Nb(a,b,c,d,f){c>>>=0;d>>>=0;f>>>=0;a=Yd[a>>>0];b=W(b>>>0);c=$d(c);return a(b,b[c],d,f)}function Pb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return a==b}var ae=()=>"object"==typeof globalThis?globalThis:Function("return this")();
81 | function Qb(a){a>>>=0;if(0===a)return X(ae());a=$d(a);return X(ae()[a])}var be=a=>{var b=Yd.length;Yd.push(a);return b},ce=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=Fd(I()[b+4*d>>>2>>>0],"parameter "+d);return c},de=(a,b)=>Object.defineProperty(b,"name",{value:a});
82 | function ee(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=de(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
83 | function Rb(a,b,c){b=ce(a,b>>>0);var d=b.shift();a--;var f="return function (obj, func, destructorsRef, args) {\n",g=0,h=[];0===c&&h.push("obj");for(var l=["retType"],m=[d],p=0;p<a;++p)h.push("arg"+p),l.push("argType"+p),m.push(b[p]),f+=` var arg${p} = argType${p}.readValueFromPointer(args${g?"+"+g:""});\n`,g+=b[p].Db;f+=` var rv = ${1===c?"new func":"func.call"}(${h.join(", ")});\n`;d.Ub||(l.push("emval_returnValue"),m.push(Gd),f+=" return emval_returnValue(retType, destructorsRef, rv);\n");l.push(f+
84 | "};\n");a=ee(l)(...m);c=`methodCaller<(${b.map(r=>r.name).join(", ")}) => ${d.name}>`;return be(de(c,a))}function Sb(a){a=$d(a>>>0);return X(e[a])}function Tb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return X(a[b])}function Ub(a){a>>>=0;9<a&&(V[a+1]+=1)}function Vb(){return X([])}function Wb(a){a=W(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return X(b)}function Xb(a){return X($d(a>>>0))}function Yb(){return X({})}
85 | function Zb(a){a>>>=0;for(var b=W(a);b.length;){var c=b.pop();b.pop()(c)}Ob(a)}function $b(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=W(b);c=W(c);a[b]=c}function ac(a,b){b>>>=0;a=Fd(a>>>0,"_emval_take_value");a=a.readValueFromPointer(b);return X(a)}
86 | function bc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getUTCSeconds();H()[b+4>>>2>>>0]=a.getUTCMinutes();H()[b+8>>>2>>>0]=a.getUTCHours();H()[b+12>>>2>>>0]=a.getUTCDate();H()[b+16>>>2>>>0]=a.getUTCMonth();H()[b+20>>>2>>>0]=a.getUTCFullYear()-1900;H()[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;H()[b+28>>>2>>>0]=a}
87 | var fe=a=>0===a%4&&(0!==a%100||0===a%400),ge=[0,31,60,91,121,152,182,213,244,274,305,335],he=[0,31,59,90,120,151,181,212,243,273,304,334];
88 | function cc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getSeconds();H()[b+4>>>2>>>0]=a.getMinutes();H()[b+8>>>2>>>0]=a.getHours();H()[b+12>>>2>>>0]=a.getDate();H()[b+16>>>2>>>0]=a.getMonth();H()[b+20>>>2>>>0]=a.getFullYear()-1900;H()[b+24>>>2>>>0]=a.getDay();var c=(fe(a.getFullYear())?ge:he)[a.getMonth()]+a.getDate()-1|0;H()[b+28>>>2>>>0]=c;H()[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
89 | var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;H()[b+32>>>2>>>0]=a}
90 | function dc(a){a>>>=0;var b=new Date(H()[a+20>>>2>>>0]+1900,H()[a+16>>>2>>>0],H()[a+12>>>2>>>0],H()[a+8>>>2>>>0],H()[a+4>>>2>>>0],H()[a>>>2>>>0],0),c=H()[a+32>>>2>>>0],d=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),g=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(g,f);0>c?H()[a+32>>>2>>>0]=Number(f!=g&&h==d):0<c!=(h==d)&&(f=Math.max(g,f),b.setTime(b.getTime()+6E4*((0<c?h:f)-d)));H()[a+24>>>2>>>0]=b.getDay();c=(fe(b.getFullYear())?ge:he)[b.getMonth()]+
91 | b.getDate()-1|0;H()[a+28>>>2>>>0]=c;H()[a>>>2>>>0]=b.getSeconds();H()[a+4>>>2>>>0]=b.getMinutes();H()[a+8>>>2>>>0]=b.getHours();H()[a+12>>>2>>>0]=b.getDate();H()[a+16>>>2>>>0]=b.getMonth();H()[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function ec(a,b,c,d,f,g,h){return q?Q(16,1,a,b,c,d,f,g,h):-52}function fc(a,b,c,d,f,g){if(q)return Q(17,1,a,b,c,d,f,g)}var ie={},qc=()=>performance.timeOrigin+performance.now();
92 | function gc(a,b){if(q)return Q(18,1,a,b);ie[a]&&(clearTimeout(ie[a].id),delete ie[a]);if(!b)return 0;var c=setTimeout(()=>{delete ie[a];Ad(()=>je(a,performance.timeOrigin+performance.now()))},b);ie[a]={id:c,rc:b};return 0}
93 | function hc(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var f=(new Date).getFullYear(),g=(new Date(f,0,1)).getTimezoneOffset();f=(new Date(f,6,1)).getTimezoneOffset();var h=Math.max(g,f);I()[a>>>2>>>0]=60*h;H()[b>>>2>>>0]=Number(g!=f);b=l=>{var m=Math.abs(l);return`UTC${0<=l?"-":"+"}${String(Math.floor(m/60)).padStart(2,"0")}${String(m%60).padStart(2,"0")}`};a=b(g);b=b(f);f<g?(gd(a,c,17),gd(b,d,17)):(gd(a,d,17),gd(b,c,17))}var mc=()=>Date.now(),ke=1;
94 | function ic(a,b,c){if(!(0<=a&&3>=a))return 28;if(0===a)a=Date.now();else if(ke)a=performance.timeOrigin+performance.now();else return 52;C[c>>>0>>>3]=BigInt(Math.round(1E6*a));return 0}var le=[],me=(a,b)=>{le.length=0;for(var c;c=F()[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;le.push(112==c?I()[b>>>2>>>0]:106==c?C[b>>>3]:105==c?H()[b>>>2>>>0]:J()[b>>>3>>>0]);b+=d?8:4}return le};function jc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}
95 | function kc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}var lc=()=>{};function nc(a,b){return x(M(a>>>0,b>>>0))}var oc=()=>{P+=1;throw"unwind";};function pc(){return 4294901760}var rc=()=>n?require("os").cpus().length:navigator.hardwareConcurrency;function sc(){L("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0}
96 | function tc(a){a>>>=0;var b=F().length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);a:{d=(Math.min(4294901760,65536*Math.ceil(Math.max(a,d)/65536))-z.buffer.byteLength+65535)/65536|0;try{z.grow(d);E();var f=1;break a}catch(g){}f=void 0}if(f)return!0}return!1}var ne=()=>{L("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0},oe={},pe=a=>{a.forEach(b=>{var c=ne();c&&(oe[c]=b)})};
97 | function uc(){var a=Error().stack.toString().split("\n");"Error"==a[0]&&a.shift();pe(a);oe.Mb=ne();oe.dc=a;return oe.Mb}function vc(a,b,c){a>>>=0;b>>>=0;if(oe.Mb==a)var d=oe.dc;else d=Error().stack.toString().split("\n"),"Error"==d[0]&&d.shift(),pe(d);for(var f=3;d[f]&&ne()!=a;)++f;for(a=0;a<c&&d[a+f];++a)H()[b+4*a>>>2>>>0]=ne();return a}
98 | var qe={},se=()=>{if(!re){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:la||"./this.program"},b;for(b in qe)void 0===qe[b]?delete a[b]:a[b]=qe[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);re=c}return re},re;
99 | function wc(a,b){if(q)return Q(19,1,a,b);a>>>=0;b>>>=0;var c=0;se().forEach((d,f)=>{var g=b+c;f=I()[a+4*f>>>2>>>0]=g;for(g=0;g<d.length;++g)D()[f++>>>0]=d.charCodeAt(g);D()[f>>>0]=0;c+=d.length+1});return 0}function xc(a,b){if(q)return Q(20,1,a,b);a>>>=0;b>>>=0;var c=se();I()[a>>>2>>>0]=c.length;var d=0;c.forEach(f=>d+=f.length+1);I()[b>>>2>>>0]=d;return 0}function zc(a){return q?Q(21,1,a):52}function Ac(a,b,c,d){return q?Q(22,1,a,b,c,d):52}function Bc(a,b,c,d){return q?Q(23,1,a,b,c,d):70}
100 | var te=[null,[],[]];function Cc(a,b,c,d){if(q)return Q(24,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var f=0,g=0;g<c;g++){var h=I()[b>>>2>>>0],l=I()[b+4>>>2>>>0];b+=8;for(var m=0;m<l;m++){var p=F()[h+m>>>0],r=te[a];0===p||10===p?((1===a?ta:x)(ed(r)),r.length=0):r.push(p)}f+=l}I()[d>>>2>>>0]=f;return 0}q||Tc();for(var ue=Array(256),ve=0;256>ve;++ve)ue[ve]=String.fromCharCode(ve);hd=ue;S=e.BindingError=class extends Error{constructor(a){super(a);this.name="BindingError"}};
101 | e.InternalError=class extends Error{constructor(a){super(a);this.name="InternalError"}};V.push(0,1,void 0,1,null,1,!0,1,!1,1);e.count_emval_handles=()=>V.length/2-5-od.length;var Dd=[Dc,Rc,cd,gb,hb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,ec,fc,gc,wc,xc,zc,Ac,Bc,Cc],bb,K;
102 | (async function(){function a(d,f){K=d.exports;K=Id();K=we();Sc.push(K.jb);va=f;Wa();return K}Ua++;var b=ab();if(e.instantiateWasm)return new Promise(d=>{e.instantiateWasm(b,(f,g)=>{a(f,g);d(f.exports)})});if(q)return new Promise(d=>{Ha=f=>{var g=new WebAssembly.Instance(f,ab());d(a(g,f))}});Xa??=e.locateFile?e.locateFile?e.locateFile("ort-wasm-simd-threaded.jsep.wasm",v):v+"ort-wasm-simd-threaded.jsep.wasm":(new URL("ort-wasm-simd-threaded.jsep.wasm",import.meta.url)).href;try{var c=await $a(b);
103 | return a(c.instance,c.module)}catch(d){return ca(d),Promise.reject(d)}})();var Ed=a=>(Ed=K.Ea)(a),Pa=()=>(Pa=K.Fa)();e._OrtInit=(a,b)=>(e._OrtInit=K.Ga)(a,b);e._OrtGetLastError=(a,b)=>(e._OrtGetLastError=K.Ha)(a,b);e._OrtCreateSessionOptions=(a,b,c,d,f,g,h,l,m,p)=>(e._OrtCreateSessionOptions=K.Ia)(a,b,c,d,f,g,h,l,m,p);e._OrtAppendExecutionProvider=(a,b,c,d,f)=>(e._OrtAppendExecutionProvider=K.Ja)(a,b,c,d,f);e._OrtAddFreeDimensionOverride=(a,b,c)=>(e._OrtAddFreeDimensionOverride=K.Ka)(a,b,c);
104 | e._OrtAddSessionConfigEntry=(a,b,c)=>(e._OrtAddSessionConfigEntry=K.La)(a,b,c);e._OrtReleaseSessionOptions=a=>(e._OrtReleaseSessionOptions=K.Ma)(a);e._OrtCreateSession=(a,b,c)=>(e._OrtCreateSession=K.Na)(a,b,c);e._OrtReleaseSession=a=>(e._OrtReleaseSession=K.Oa)(a);e._OrtGetInputOutputCount=(a,b,c)=>(e._OrtGetInputOutputCount=K.Pa)(a,b,c);e._OrtGetInputOutputMetadata=(a,b,c,d)=>(e._OrtGetInputOutputMetadata=K.Qa)(a,b,c,d);e._OrtFree=a=>(e._OrtFree=K.Ra)(a);
105 | e._OrtCreateTensor=(a,b,c,d,f,g)=>(e._OrtCreateTensor=K.Sa)(a,b,c,d,f,g);e._OrtGetTensorData=(a,b,c,d,f)=>(e._OrtGetTensorData=K.Ta)(a,b,c,d,f);e._OrtReleaseTensor=a=>(e._OrtReleaseTensor=K.Ua)(a);e._OrtCreateRunOptions=(a,b,c,d)=>(e._OrtCreateRunOptions=K.Va)(a,b,c,d);e._OrtAddRunConfigEntry=(a,b,c)=>(e._OrtAddRunConfigEntry=K.Wa)(a,b,c);e._OrtReleaseRunOptions=a=>(e._OrtReleaseRunOptions=K.Xa)(a);e._OrtCreateBinding=a=>(e._OrtCreateBinding=K.Ya)(a);
106 | e._OrtBindInput=(a,b,c)=>(e._OrtBindInput=K.Za)(a,b,c);e._OrtBindOutput=(a,b,c,d)=>(e._OrtBindOutput=K._a)(a,b,c,d);e._OrtClearBoundOutputs=a=>(e._OrtClearBoundOutputs=K.$a)(a);e._OrtReleaseBinding=a=>(e._OrtReleaseBinding=K.ab)(a);e._OrtRunWithBinding=(a,b,c,d,f)=>(e._OrtRunWithBinding=K.bb)(a,b,c,d,f);e._OrtRun=(a,b,c,d,f,g,h,l)=>(e._OrtRun=K.cb)(a,b,c,d,f,g,h,l);e._OrtEndProfiling=a=>(e._OrtEndProfiling=K.db)(a);e._JsepOutput=(a,b,c)=>(e._JsepOutput=K.eb)(a,b,c);
107 | e._JsepGetNodeName=a=>(e._JsepGetNodeName=K.fb)(a);
108 | var Ka=()=>(Ka=K.gb)(),Y=e._free=a=>(Y=e._free=K.hb)(a),sd=e._malloc=a=>(sd=e._malloc=K.ib)(a),Ma=(a,b,c,d,f,g)=>(Ma=K.lb)(a,b,c,d,f,g),Sa=()=>(Sa=K.mb)(),Pc=(a,b,c,d,f)=>(Pc=K.nb)(a,b,c,d,f),Vc=a=>(Vc=K.ob)(a),Zc=a=>(Zc=K.pb)(a),je=(a,b)=>(je=K.qb)(a,b),Bd=()=>(Bd=K.rb)(),Xc=(a,b)=>(Xc=K.sb)(a,b),Qc=a=>(Qc=K.tb)(a),Oc=a=>(Oc=K.ub)(a),Nc=()=>(Nc=K.vb)(),Yc=e.dynCall_ii=(a,b)=>(Yc=e.dynCall_ii=K.wb)(a,b),Vd=a=>(Vd=K.xb)(a),Kd=()=>(Kd=K.yb)(),Ud=a=>(Ud=K.zb)(a),Xd=()=>(Xd=K.Ab)();
109 | function we(){var a=K;a=Object.assign({},a);var b=d=>f=>d(f)>>>0,c=d=>()=>d()>>>0;a.Ea=b(a.Ea);a.gb=c(a.gb);a.ib=b(a.ib);a.ub=b(a.ub);a.vb=c(a.vb);a.__cxa_get_exception_ptr=b(a.__cxa_get_exception_ptr);return a}e.stackSave=()=>Nc();e.stackRestore=a=>Qc(a);e.stackAlloc=a=>Oc(a);
110 | e.setValue=function(a,b,c="i8"){c.endsWith("*")&&(c="*");switch(c){case "i1":D()[a>>>0]=b;break;case "i8":D()[a>>>0]=b;break;case "i16":G()[a>>>1>>>0]=b;break;case "i32":H()[a>>>2>>>0]=b;break;case "i64":C[a>>>3]=BigInt(b);break;case "float":Ga()[a>>>2>>>0]=b;break;case "double":J()[a>>>3>>>0]=b;break;case "*":I()[a>>>2>>>0]=b;break;default:L(`invalid type for setValue: ${c}`)}};
111 | e.getValue=function(a,b="i8"){b.endsWith("*")&&(b="*");switch(b){case "i1":return D()[a>>>0];case "i8":return D()[a>>>0];case "i16":return G()[a>>>1>>>0];case "i32":return H()[a>>>2>>>0];case "i64":return C[a>>>3];case "float":return Ga()[a>>>2>>>0];case "double":return J()[a>>>3>>>0];case "*":return I()[a>>>2>>>0];default:L(`invalid type for getValue: ${b}`)}};e.UTF8ToString=M;e.stringToUTF8=gd;e.lengthBytesUTF8=fd;
112 | function xe(){if(0<Ua)Va=xe;else if(q)aa(e),Ta();else{for(;0<Ic.length;)Ic.shift()(e);0<Ua?Va=xe:(e.calledRun=!0,A||(Ta(),aa(e)))}}xe();e.PTR_SIZE=4;moduleRtn=da;
113 |
114 |
115 | return moduleRtn;
116 | }
117 | );
118 | })();
119 | export default ortWasmThreaded;
120 | var isPthread = globalThis.self?.name?.startsWith('em-pthread');
121 | var isNode = typeof globalThis.process?.versions?.node == 'string';
122 | if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread';
123 |
124 | // When running as a pthread, construct a new instance on startup
125 | isPthread && ortWasmThreaded();
126 |
```
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/sidepanel/components/AgentChat.vue:
--------------------------------------------------------------------------------
```vue
1 | <template>
2 | <div class="agent-theme relative h-full" :data-agent-theme="themeState.theme.value">
3 | <!-- Sessions List View -->
4 | <template v-if="viewRoute.isSessionsView.value">
5 | <AgentSessionsView
6 | :sessions="sessions.allSessions.value"
7 | :selected-session-id="sessions.selectedSessionId.value"
8 | :is-loading="sessions.isLoadingAllSessions.value"
9 | :is-creating="sessions.isCreatingSession.value"
10 | :error="sessions.sessionError.value"
11 | :running-session-ids="runningSessionIds"
12 | :projects-map="projectsMap"
13 | @session:select="handleSessionSelectAndNavigate"
14 | @session:new="handleNewSessionAndNavigate"
15 | @session:delete="handleDeleteSession"
16 | @session:rename="handleRenameSession"
17 | @session:open-project="handleSessionOpenProject"
18 | />
19 | </template>
20 |
21 | <!-- Chat Conversation View -->
22 | <template v-else>
23 | <AgentChatShell
24 | :error-message="chat.errorMessage.value"
25 | :usage="chat.lastUsage.value"
26 | :footer-label="`${engineDisplayName} Preview`"
27 | @error:dismiss="chat.errorMessage.value = null"
28 | >
29 | <!-- Header -->
30 | <template #header>
31 | <AgentTopBar
32 | :project-label="projectLabel"
33 | :session-label="sessionLabel"
34 | :connection-state="connectionState"
35 | :show-back-button="true"
36 | :brand-label="engineDisplayName"
37 | @toggle:project-menu="toggleProjectMenu"
38 | @toggle:session-menu="toggleSessionMenu"
39 | @toggle:settings-menu="toggleSettingsMenu"
40 | @toggle:open-project-menu="toggleOpenProjectMenu"
41 | @back="handleBackToSessions"
42 | />
43 | </template>
44 |
45 | <!-- Content -->
46 | <template #content>
47 | <AgentConversation :threads="threadState.threads.value" />
48 | </template>
49 |
50 | <!-- Composer -->
51 | <template #composer>
52 | <!-- Web Editor Changes Chips -->
53 | <WebEditorChanges />
54 |
55 | <AgentComposer
56 | :model-value="chat.input.value"
57 | :attachments="attachments.attachments.value"
58 | :attachment-error="attachments.error.value"
59 | :is-drag-over="attachments.isDragOver.value"
60 | :is-streaming="chat.isStreaming.value"
61 | :request-state="chat.requestState.value"
62 | :sending="chat.sending.value"
63 | :cancelling="chat.cancelling.value"
64 | :can-cancel="!!chat.currentRequestId.value"
65 | :can-send="chat.canSend.value"
66 | placeholder="Ask Claude to write code..."
67 | :engine-name="currentEngineName"
68 | :selected-model="currentSessionModel"
69 | :available-models="currentAvailableModels"
70 | :reasoning-effort="currentReasoningEffort"
71 | :available-reasoning-efforts="currentAvailableReasoningEfforts"
72 | :enable-fake-caret="inputPreferences.fakeCaretEnabled.value"
73 | @update:model-value="chat.input.value = $event"
74 | @submit="handleSend"
75 | @cancel="chat.cancelCurrentRequest()"
76 | @attachment:add="handleAttachmentAdd"
77 | @attachment:remove="attachments.removeAttachment"
78 | @attachment:drop="attachments.handleDrop"
79 | @attachment:paste="attachments.handlePaste"
80 | @attachment:dragover="attachments.handleDragOver"
81 | @attachment:dragleave="attachments.handleDragLeave"
82 | @model:change="handleComposerModelChange"
83 | @reasoning-effort:change="handleComposerReasoningEffortChange"
84 | @session:settings="handleComposerOpenSettings"
85 | @session:reset="handleComposerReset"
86 | />
87 | </template>
88 | </AgentChatShell>
89 | </template>
90 |
91 | <!-- Click-outside handler for menus (z-40) -->
92 | <div
93 | v-if="projectMenuOpen || sessionMenuOpen || settingsMenuOpen || openProjectMenuOpen"
94 | class="fixed inset-0 z-40"
95 | @click="closeMenus"
96 | />
97 |
98 | <!-- Dropdown menus (z-50, outside stacking context) -->
99 | <AgentProjectMenu
100 | :open="projectMenuOpen"
101 | :projects="projects.projects.value"
102 | :selected-project-id="projects.selectedProjectId.value"
103 | :selected-cli="selectedCli"
104 | :model="model"
105 | :reasoning-effort="reasoningEffort"
106 | :use-ccr="useCcr"
107 | :enable-chrome-mcp="enableChromeMcp"
108 | :engines="server.engines.value"
109 | :is-picking="isPickingDirectory"
110 | :is-saving="isSavingPreference"
111 | :error="projects.projectError.value"
112 | @project:select="handleProjectSelect"
113 | @project:new="handleNewProject"
114 | @cli:update="selectedCli = $event"
115 | @model:update="model = $event"
116 | @reasoning-effort:update="reasoningEffort = $event"
117 | @ccr:update="useCcr = $event"
118 | @chrome-mcp:update="enableChromeMcp = $event"
119 | @save="handleSaveSettings"
120 | />
121 |
122 | <AgentSessionMenu
123 | :open="sessionMenuOpen"
124 | :sessions="sessions.sessions.value"
125 | :selected-session-id="sessions.selectedSessionId.value"
126 | :is-loading="sessions.isLoadingSessions.value"
127 | :is-creating="sessions.isCreatingSession.value"
128 | :error="sessions.sessionError.value"
129 | @session:select="handleSessionSelect"
130 | @session:new="handleNewSession"
131 | @session:delete="handleDeleteSession"
132 | @session:rename="handleRenameSession"
133 | />
134 |
135 | <AgentSettingsMenu
136 | :open="settingsMenuOpen"
137 | :theme="themeState.theme.value"
138 | :fake-caret-enabled="inputPreferences.fakeCaretEnabled.value"
139 | @theme:set="handleThemeChange"
140 | @reconnect="handleReconnect"
141 | @attachments:open="handleOpenAttachmentCache"
142 | @fake-caret:toggle="handleFakeCaretToggle"
143 | />
144 |
145 | <AgentOpenProjectMenu
146 | :open="openProjectMenuOpen"
147 | :default-target="openProjectPreference.defaultTarget.value"
148 | @select="handleOpenProjectSelect"
149 | @close="closeOpenProjectMenu"
150 | />
151 |
152 | <!-- Session Settings Panel -->
153 | <AgentSessionSettingsPanel
154 | :open="sessionSettingsOpen"
155 | :session="sessions.selectedSession.value"
156 | :management-info="currentManagementInfo"
157 | :is-loading="sessionSettingsLoading"
158 | :is-saving="sessionSettingsSaving"
159 | @close="handleCloseSessionSettings"
160 | @save="handleSaveSessionSettings"
161 | />
162 |
163 | <!-- Attachment Cache Panel -->
164 | <AttachmentCachePanel :open="attachmentCacheOpen" @close="handleCloseAttachmentCache" />
165 | </div>
166 | </template>
167 |
168 | <script lang="ts" setup>
169 | import { ref, computed, onMounted, onUnmounted, watch, provide } from 'vue';
170 | import type { AgentStoredMessage, AgentMessage, CodexReasoningEffort } from 'chrome-mcp-shared';
171 |
172 | // Composables
173 | import {
174 | useAgentServer,
175 | useAgentChat,
176 | useAgentProjects,
177 | useAgentSessions,
178 | useAttachments,
179 | useAgentTheme,
180 | useAgentThreads,
181 | useWebEditorTxState,
182 | useAgentChatViewRoute,
183 | useOpenProjectPreference,
184 | useAgentInputPreferences,
185 | WEB_EDITOR_TX_STATE_INJECTION_KEY,
186 | AGENT_SERVER_PORT_KEY,
187 | type AgentThemeId,
188 | } from '../composables';
189 | import type { OpenProjectTarget } from 'chrome-mcp-shared';
190 |
191 | // New UI Components
192 | import {
193 | AgentChatShell,
194 | AgentTopBar,
195 | AgentComposer,
196 | WebEditorChanges,
197 | AgentConversation,
198 | AgentProjectMenu,
199 | AgentSessionMenu,
200 | AgentSettingsMenu,
201 | AgentSessionSettingsPanel,
202 | AgentSessionsView,
203 | AgentOpenProjectMenu,
204 | } from './agent-chat';
205 | import type { SessionSettings } from './agent-chat/AgentSessionSettingsPanel.vue';
206 | import AttachmentCachePanel from './agent-chat/AttachmentCachePanel.vue';
207 |
208 | // Model utilities
209 | import {
210 | getModelsForCli,
211 | getCodexReasoningEfforts,
212 | getDefaultModelForCli,
213 | } from '@/common/agent-models';
214 | import { BACKGROUND_MESSAGE_TYPES } from '@/common/message-types';
215 |
216 | // Local UI state
217 | const selectedCli = ref('');
218 | const model = ref('');
219 | const reasoningEffort = ref<CodexReasoningEffort>('medium');
220 | const useCcr = ref(false);
221 | const enableChromeMcp = ref(true);
222 | const isSavingPreference = ref(false);
223 |
224 | /**
225 | * Get normalized model value that is valid for the current CLI.
226 | * Returns empty string if:
227 | * - No CLI selected (use server default)
228 | * - Model is invalid for selected CLI
229 | */
230 | function getNormalizedModel(): string {
231 | const trimmedModel = model.value.trim();
232 | if (!trimmedModel) return '';
233 | // No CLI selected = don't override model, let server use default
234 | if (!selectedCli.value) return '';
235 | const models = getModelsForCli(selectedCli.value);
236 | if (models.length === 0) return ''; // Unknown CLI
237 | const isValid = models.some((m) => m.id === trimmedModel);
238 | return isValid ? trimmedModel : '';
239 | }
240 |
241 | /**
242 | * Get normalized reasoning effort that is valid for the current model.
243 | * Used when creating/updating codex sessions.
244 | */
245 | function getNormalizedReasoningEffort(): CodexReasoningEffort {
246 | if (selectedCli.value !== 'codex') return 'medium';
247 | const effectiveModel = getNormalizedModel() || getDefaultModelForCli('codex');
248 | const supported = getCodexReasoningEfforts(effectiveModel);
249 | return supported.includes(reasoningEffort.value)
250 | ? reasoningEffort.value
251 | : (supported[supported.length - 1] as CodexReasoningEffort);
252 | }
253 |
254 | const isPickingDirectory = ref(false);
255 | const projectMenuOpen = ref(false);
256 | const sessionMenuOpen = ref(false);
257 | const settingsMenuOpen = ref(false);
258 | const openProjectMenuOpen = ref(false);
259 |
260 | // Open project context: which session/project to open when menu selects
261 | const openProjectContext = ref<{ type: 'session' | 'project'; id: string } | null>(null);
262 |
263 | // Session settings panel state
264 | const sessionSettingsOpen = ref(false);
265 | const sessionSettingsLoading = ref(false);
266 | const sessionSettingsSaving = ref(false);
267 | const currentManagementInfo = ref<import('chrome-mcp-shared').AgentManagementInfo | null>(null);
268 |
269 | // Attachment cache panel state
270 | const attachmentCacheOpen = ref(false);
271 |
272 | // Initialize composables - sessions must be declared first for sessionId access
273 | const sessions = useAgentSessions({
274 | getServerPort: () => server.serverPort.value,
275 | ensureServer: () => server.ensureNativeServer(),
276 | onSessionChanged: (sessionId: string) => {
277 | // Guard against stale callbacks from concurrent session switches
278 | // This prevents race conditions where an older switch completes after a newer one
279 | if (sessionId !== sessions.selectedSessionId.value) {
280 | return;
281 | }
282 |
283 | // Always clear request state when session changes, regardless of view
284 | // This prevents stale cancel targets and running badges from carrying over
285 | chat.currentRequestId.value = null;
286 | chat.isStreaming.value = false;
287 | chat.requestState.value = 'idle';
288 |
289 | // Always sync URL when session changes (for all paths: delete, project switch, etc.)
290 | // This ensures URL stays consistent for refresh/deep-link scenarios
291 | viewRoute.setSessionId(sessionId);
292 |
293 | // Only reconnect SSE and reload history if we're in chat view
294 | // This prevents duplicate connections when switching sessions from the list
295 | // The list->chat navigation handlers will open SSE themselves
296 | if (viewRoute.isChatView.value && projects.selectedProjectId.value) {
297 | server.openEventSource();
298 | void loadSessionHistory(sessionId);
299 | }
300 | },
301 | });
302 |
303 | const server = useAgentServer({
304 | getSessionId: () => sessions.selectedSessionId.value,
305 | onMessage: (event) => chat.handleRealtimeEvent(event),
306 | onError: (error) => {
307 | chat.errorMessage.value = error;
308 | },
309 | });
310 |
311 | const chat = useAgentChat({
312 | getServerPort: () => server.serverPort.value,
313 | getSessionId: () => sessions.selectedSessionId.value,
314 | ensureServer: () => server.ensureNativeServer(),
315 | openEventSource: () => server.openEventSource(),
316 | });
317 |
318 | const projects = useAgentProjects({
319 | getServerPort: () => server.serverPort.value,
320 | ensureServer: () => server.ensureNativeServer(),
321 | onHistoryLoaded: (messages: AgentStoredMessage[]) => {
322 | const converted = convertStoredMessages(messages);
323 | chat.setMessages(converted);
324 | },
325 | });
326 |
327 | const attachments = useAttachments();
328 | const themeState = useAgentTheme();
329 | const openProjectPreference = useOpenProjectPreference({
330 | getServerPort: () => server.serverPort.value,
331 | });
332 | const inputPreferences = useAgentInputPreferences();
333 |
334 | // Initialize Web Editor TX state at root level and provide to children
335 | // This prevents duplicate listener registration in child components
336 | const webEditorTxState = useWebEditorTxState();
337 | provide(WEB_EDITOR_TX_STATE_INJECTION_KEY, webEditorTxState);
338 |
339 | // Provide server port for child components to build attachment URLs
340 | provide(AGENT_SERVER_PORT_KEY, server.serverPort);
341 |
342 | // View routing (sessions list vs chat conversation)
343 | const viewRoute = useAgentChatViewRoute();
344 |
345 | // Track running sessions for badge display
346 | const runningSessionIds = computed(() => {
347 | // For now, only track current session's running state
348 | // Could be extended to track multiple sessions via background broadcast
349 | const currentId = sessions.selectedSessionId.value;
350 | // Use isRequestActive instead of isStreaming to correctly show running badge
351 | // even during tool execution when isStreaming might be false
352 | if (currentId && chat.isRequestActive.value) {
353 | return new Set([currentId]);
354 | }
355 | return new Set<string>();
356 | });
357 |
358 | // Map of projectId -> AgentProject for looking up project info in sessions list
359 | const projectsMap = computed(() => {
360 | return new Map(projects.projects.value.map((p) => [p.id, p] as const));
361 | });
362 |
363 | // Thread state for grouping messages
364 | const threadState = useAgentThreads({
365 | messages: chat.messages,
366 | requestState: chat.requestState,
367 | currentRequestId: chat.currentRequestId,
368 | });
369 |
370 | // Computed values
371 | const projectLabel = computed(() => {
372 | const project = projects.selectedProject.value;
373 | return project?.name ?? 'No project';
374 | });
375 |
376 | const sessionLabel = computed(() => {
377 | const session = sessions.selectedSession.value;
378 | // Priority: preview (first user message) > name > 'New Session'
379 | return session?.preview || session?.name || 'New Session';
380 | });
381 |
382 | const connectionState = computed(() => {
383 | if (server.isServerReady.value) return 'ready';
384 | if (server.nativeConnected.value) return 'connecting';
385 | return 'disconnected';
386 | });
387 |
388 | // Computed values for AgentComposer
389 | const currentEngineName = computed(() => sessions.selectedSession.value?.engineName ?? '');
390 |
391 | // Engine display name for brand/footer
392 | const engineDisplayName = computed(() => {
393 | const name = currentEngineName.value;
394 | switch (name) {
395 | case 'claude':
396 | return 'Claude Code';
397 | case 'codex':
398 | return 'Codex';
399 | case 'cursor':
400 | return 'Cursor';
401 | case 'qwen':
402 | return 'Qwen';
403 | case 'glm':
404 | return 'GLM';
405 | default:
406 | return 'Agent';
407 | }
408 | });
409 |
410 | const currentSessionModel = computed(() => {
411 | const session = sessions.selectedSession.value;
412 | if (!session) return '';
413 | // Use session model if set, otherwise use default for the engine
414 | return session.model || getDefaultModelForCli(session.engineName);
415 | });
416 |
417 | const currentAvailableModels = computed(() => {
418 | const session = sessions.selectedSession.value;
419 | if (!session) return [];
420 | return getModelsForCli(session.engineName);
421 | });
422 |
423 | const currentReasoningEffort = computed(() => {
424 | const session = sessions.selectedSession.value;
425 | if (!session || session.engineName !== 'codex') return 'medium' as CodexReasoningEffort;
426 | return session.optionsConfig?.codexConfig?.reasoningEffort ?? 'medium';
427 | });
428 |
429 | const currentAvailableReasoningEfforts = computed(() => {
430 | const session = sessions.selectedSession.value;
431 | if (!session || session.engineName !== 'codex') return [] as readonly CodexReasoningEffort[];
432 | const effectiveModel = currentSessionModel.value || getDefaultModelForCli('codex');
433 | return getCodexReasoningEfforts(effectiveModel);
434 | });
435 |
436 | // Track pending history load with nonce to prevent A→B→A race conditions
437 | let historyLoadNonce = 0;
438 |
439 | /**
440 | * Load chat history for a specific session with race-condition protection.
441 | * Uses a nonce to handle A→B→A scenarios where older requests for the same
442 | * session could return after newer ones.
443 | */
444 | async function loadSessionHistory(sessionId: string): Promise<void> {
445 | const serverPort = server.serverPort.value;
446 | if (!serverPort || !sessionId) return;
447 |
448 | // Increment nonce for this load - any subsequent load will invalidate this one
449 | const myNonce = ++historyLoadNonce;
450 |
451 | /**
452 | * Check if this load is still valid.
453 | * Validates both the nonce (handles A→B→A) and current selection (handles switches).
454 | */
455 | const isStillValid = (): boolean => {
456 | return myNonce === historyLoadNonce && sessions.selectedSessionId.value === sessionId;
457 | };
458 |
459 | try {
460 | const url = `http://127.0.0.1:${serverPort}/agent/sessions/${encodeURIComponent(sessionId)}/history`;
461 | const response = await fetch(url);
462 |
463 | if (!isStillValid()) return;
464 |
465 | if (response.ok) {
466 | const data = await response.json();
467 |
468 | // Re-check after json parsing (parsing can be slow for large histories)
469 | if (!isStillValid()) return;
470 |
471 | const messages = data.messages || [];
472 | const converted = convertStoredMessages(messages);
473 | chat.setMessages(converted);
474 | } else {
475 | if (!isStillValid()) return;
476 | chat.setMessages([]);
477 | }
478 | } catch (error) {
479 | if (isStillValid()) {
480 | console.error('Failed to load session history:', error);
481 | chat.setMessages([]);
482 | }
483 | }
484 | }
485 |
486 | // Convert stored messages to AgentMessage format
487 | function convertStoredMessages(stored: AgentStoredMessage[]): AgentMessage[] {
488 | return stored.map((m) => ({
489 | id: m.id,
490 | sessionId: m.sessionId,
491 | role: m.role,
492 | content: m.content,
493 | messageType: m.messageType,
494 | cliSource: m.cliSource ?? undefined,
495 | requestId: m.requestId,
496 | createdAt: m.createdAt ?? new Date().toISOString(),
497 | metadata: m.metadata,
498 | }));
499 | }
500 |
501 | /**
502 | * Clear streaming/request state when switching sessions.
503 | * Prevents stale cancel targets and running badges from carrying over.
504 | */
505 | function clearRequestState(): void {
506 | chat.currentRequestId.value = null;
507 | chat.isStreaming.value = false;
508 | chat.requestState.value = 'idle';
509 | }
510 |
511 | // Menu handlers
512 | function toggleProjectMenu(): void {
513 | projectMenuOpen.value = !projectMenuOpen.value;
514 | if (projectMenuOpen.value) {
515 | sessionMenuOpen.value = false;
516 | settingsMenuOpen.value = false;
517 | openProjectMenuOpen.value = false;
518 | }
519 | }
520 |
521 | function toggleSessionMenu(): void {
522 | sessionMenuOpen.value = !sessionMenuOpen.value;
523 | if (sessionMenuOpen.value) {
524 | projectMenuOpen.value = false;
525 | settingsMenuOpen.value = false;
526 | openProjectMenuOpen.value = false;
527 | }
528 | }
529 |
530 | function toggleSettingsMenu(): void {
531 | settingsMenuOpen.value = !settingsMenuOpen.value;
532 | if (settingsMenuOpen.value) {
533 | projectMenuOpen.value = false;
534 | sessionMenuOpen.value = false;
535 | openProjectMenuOpen.value = false;
536 | }
537 | }
538 |
539 | function toggleOpenProjectMenu(): void {
540 | openProjectMenuOpen.value = !openProjectMenuOpen.value;
541 | if (openProjectMenuOpen.value) {
542 | projectMenuOpen.value = false;
543 | sessionMenuOpen.value = false;
544 | settingsMenuOpen.value = false;
545 | // Set context to current session from chat view
546 | const sessionId = sessions.selectedSessionId.value;
547 | if (sessionId) {
548 | openProjectContext.value = { type: 'session', id: sessionId };
549 | }
550 | } else {
551 | openProjectContext.value = null;
552 | }
553 | }
554 |
555 | function closeOpenProjectMenu(): void {
556 | openProjectMenuOpen.value = false;
557 | openProjectContext.value = null;
558 | }
559 |
560 | /**
561 | * Handle session list item's open-project button click.
562 | * If user has a default preference, open directly; otherwise show menu.
563 | */
564 | async function handleSessionOpenProject(sessionId: string): Promise<void> {
565 | const defaultTarget = openProjectPreference.defaultTarget.value;
566 | if (defaultTarget) {
567 | // User has default preference, open directly
568 | const result = await openProjectPreference.openBySession(sessionId, defaultTarget);
569 | if (!result.success) {
570 | alert(`Failed to open project: ${result.error}`);
571 | }
572 | } else {
573 | // No default, show menu
574 | openProjectContext.value = { type: 'session', id: sessionId };
575 | openProjectMenuOpen.value = true;
576 | projectMenuOpen.value = false;
577 | sessionMenuOpen.value = false;
578 | settingsMenuOpen.value = false;
579 | }
580 | }
581 |
582 | /**
583 | * Handle open project menu selection.
584 | * Saves preference and opens the project.
585 | */
586 | async function handleOpenProjectSelect(target: OpenProjectTarget): Promise<void> {
587 | // Snapshot context before any await to prevent race condition
588 | // (close event may clear context while we're awaiting)
589 | const ctx = openProjectContext.value;
590 |
591 | // Close menu immediately for better UX
592 | closeOpenProjectMenu();
593 |
594 | if (!ctx) return;
595 |
596 | // Save as default preference (non-blocking for UX)
597 | void openProjectPreference.saveDefaultTarget(target);
598 |
599 | // Execute open action based on context
600 | let result;
601 | if (ctx.type === 'session') {
602 | result = await openProjectPreference.openBySession(ctx.id, target);
603 | } else {
604 | result = await openProjectPreference.openByProject(ctx.id, target);
605 | }
606 |
607 | if (!result.success) {
608 | alert(`Failed to open project: ${result.error}`);
609 | }
610 | }
611 |
612 | function closeMenus(): void {
613 | projectMenuOpen.value = false;
614 | sessionMenuOpen.value = false;
615 | settingsMenuOpen.value = false;
616 | openProjectMenuOpen.value = false;
617 | openProjectContext.value = null;
618 | }
619 |
620 | // Theme handler
621 | async function handleThemeChange(theme: AgentThemeId): Promise<void> {
622 | await themeState.setTheme(theme);
623 | closeMenus();
624 | }
625 |
626 | // Fake caret toggle handler
627 | async function handleFakeCaretToggle(enabled: boolean): Promise<void> {
628 | await inputPreferences.setFakeCaretEnabled(enabled);
629 | }
630 |
631 | // Server reconnect
632 | async function handleReconnect(): Promise<void> {
633 | closeMenus();
634 | await server.reconnect();
635 | }
636 |
637 | // Attachment cache handlers
638 | function handleOpenAttachmentCache(): void {
639 | attachmentCacheOpen.value = true;
640 | sessionSettingsOpen.value = false;
641 | closeMenus();
642 | }
643 |
644 | function handleCloseAttachmentCache(): void {
645 | attachmentCacheOpen.value = false;
646 | }
647 |
648 | // Session handlers
649 | async function handleSessionSelect(sessionId: string): Promise<void> {
650 | await sessions.selectSession(sessionId);
651 | // Note: URL sync is handled by onSessionChanged callback
652 | closeMenus();
653 | }
654 |
655 | async function handleNewSession(): Promise<void> {
656 | const projectId = projects.selectedProjectId.value;
657 | if (!projectId) return;
658 |
659 | // Clear previous request state (in chat view, creating new session should reset state)
660 | clearRequestState();
661 |
662 | const engineName =
663 | (selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm') || 'claude';
664 |
665 | // Include codex config if using codex engine
666 | const optionsConfig =
667 | engineName === 'codex'
668 | ? {
669 | codexConfig: {
670 | reasoningEffort: getNormalizedReasoningEffort(),
671 | },
672 | }
673 | : undefined;
674 |
675 | const session = await sessions.createSession(projectId, {
676 | engineName,
677 | name: `Session ${sessions.sessions.value.length + 1}`,
678 | optionsConfig,
679 | });
680 |
681 | // Guard: only clear messages if the new session is still selected
682 | // This prevents clearing messages if user switched during createSession await
683 | if (session && sessions.selectedSessionId.value === session.id) {
684 | chat.setMessages([]);
685 | // Note: URL sync is handled by onSessionChanged callback (triggered by createSession)
686 | }
687 | closeMenus();
688 | }
689 |
690 | async function handleDeleteSession(sessionId: string): Promise<void> {
691 | const wasCurrentSession = sessions.selectedSessionId.value === sessionId;
692 | const wasInChatView = viewRoute.isChatView.value;
693 |
694 | await sessions.deleteSession(sessionId);
695 |
696 | // Handle post-delete navigation and URL sync
697 | if (wasCurrentSession) {
698 | if (sessions.sessions.value.length === 0) {
699 | // No sessions left - go back to sessions list (will show empty state)
700 | // Also clear URL sessionId since there's no valid session
701 | viewRoute.setSessionId(null);
702 | if (wasInChatView) {
703 | viewRoute.goToSessions();
704 | }
705 | }
706 | // Note: If there are remaining sessions, useAgentSessions.deleteSession
707 | // already calls onSessionChanged which syncs URL via setSessionId
708 | }
709 | }
710 |
711 | async function handleRenameSession(sessionId: string, name: string): Promise<void> {
712 | await sessions.renameSession(sessionId, name);
713 | }
714 |
715 | async function handleOpenSessionSettings(sessionId: string): Promise<void> {
716 | closeMenus();
717 | sessionSettingsOpen.value = true;
718 | sessionSettingsLoading.value = true;
719 | currentManagementInfo.value = null;
720 |
721 | try {
722 | // Fetch Claude SDK management info if this is a Claude session
723 | const session = sessions.sessions.value.find((s) => s.id === sessionId);
724 | if (session?.engineName === 'claude') {
725 | const info = await sessions.fetchClaudeInfo(sessionId);
726 | if (info) {
727 | currentManagementInfo.value = info.managementInfo;
728 | }
729 | }
730 | } finally {
731 | sessionSettingsLoading.value = false;
732 | }
733 | }
734 |
735 | async function handleResetSession(sessionId: string): Promise<void> {
736 | closeMenus();
737 | const result = await sessions.resetConversation(sessionId);
738 | // Guard: only clear messages if the reset session is still selected
739 | // This prevents clearing messages if user switched during reset await
740 | if (result && sessions.selectedSessionId.value === sessionId) {
741 | chat.setMessages([]);
742 | }
743 | }
744 |
745 | // Composer direct model/reasoning effort change handlers
746 | async function handleComposerModelChange(modelId: string): Promise<void> {
747 | const sessionId = sessions.selectedSessionId.value;
748 | if (!sessionId) return;
749 |
750 | await sessions.updateSession(sessionId, { model: modelId || null });
751 | }
752 |
753 | async function handleComposerReasoningEffortChange(effort: CodexReasoningEffort): Promise<void> {
754 | const sessionId = sessions.selectedSessionId.value;
755 | const session = sessions.selectedSession.value;
756 | if (!sessionId || !session) return;
757 |
758 | const existingOptions = session.optionsConfig ?? {};
759 | const existingCodexConfig = existingOptions.codexConfig ?? {};
760 | await sessions.updateSession(sessionId, {
761 | optionsConfig: {
762 | ...existingOptions,
763 | codexConfig: {
764 | ...existingCodexConfig,
765 | reasoningEffort: effort,
766 | },
767 | },
768 | });
769 | }
770 |
771 | // Composer session settings/reset handlers (without sessionId parameter)
772 | function handleComposerOpenSettings(): void {
773 | const sessionId = sessions.selectedSessionId.value;
774 | if (sessionId) {
775 | handleOpenSessionSettings(sessionId);
776 | }
777 | }
778 |
779 | async function handleComposerReset(): Promise<void> {
780 | const sessionId = sessions.selectedSessionId.value;
781 | if (sessionId) {
782 | await handleResetSession(sessionId);
783 | }
784 | }
785 |
786 | function handleCloseSessionSettings(): void {
787 | sessionSettingsOpen.value = false;
788 | currentManagementInfo.value = null;
789 | }
790 |
791 | async function handleSaveSessionSettings(settings: SessionSettings): Promise<void> {
792 | const sessionId = sessions.selectedSessionId.value;
793 | if (!sessionId) return;
794 |
795 | sessionSettingsSaving.value = true;
796 | try {
797 | await sessions.updateSession(sessionId, {
798 | model: settings.model || null,
799 | permissionMode: settings.permissionMode || null,
800 | systemPromptConfig: settings.systemPromptConfig,
801 | optionsConfig: settings.optionsConfig,
802 | });
803 | sessionSettingsOpen.value = false;
804 | currentManagementInfo.value = null;
805 | } finally {
806 | sessionSettingsSaving.value = false;
807 | }
808 | }
809 |
810 | // Project handlers
811 | async function handleProjectSelect(projectId: string): Promise<void> {
812 | // Clear request state and sessions before switching project
813 | // This prevents stale session data from mixing with the new project
814 | clearRequestState();
815 | sessions.clearSessions();
816 |
817 | projects.selectedProjectId.value = projectId;
818 | await projects.handleProjectChanged();
819 |
820 | // Guard: abort if user switched to a different project during await
821 | if (projects.selectedProjectId.value !== projectId) {
822 | closeMenus();
823 | return;
824 | }
825 |
826 | const project = projects.selectedProject.value;
827 | if (project) {
828 | selectedCli.value = project.preferredCli ?? '';
829 | model.value = project.selectedModel ?? '';
830 | useCcr.value = project.useCcr ?? false;
831 | enableChromeMcp.value = project.enableChromeMcp !== false;
832 | }
833 | // Load sessions for the new project
834 | await sessions.ensureDefaultSession(
835 | projectId,
836 | (selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm') || 'claude',
837 | );
838 |
839 | // Guard again after ensureDefaultSession
840 | if (projects.selectedProjectId.value !== projectId) {
841 | closeMenus();
842 | return;
843 | }
844 |
845 | // Ensure URL is synced after project switch (fallback for edge cases)
846 | // This handles rare cases where ensureDefaultSession doesn't trigger onSessionChanged
847 | viewRoute.setSessionId(sessions.selectedSessionId.value || null);
848 |
849 | closeMenus();
850 | }
851 |
852 | async function handleNewProject(): Promise<void> {
853 | isPickingDirectory.value = true;
854 | try {
855 | const path = await projects.pickDirectory();
856 | if (path) {
857 | // Extract directory name from path, handling trailing slashes
858 | const segments = path.split(/[/\\]/).filter((s) => s.length > 0);
859 | const dirName = segments.pop() || 'New Project';
860 | const project = await projects.createProjectFromPath(path, dirName);
861 | if (project) {
862 | selectedCli.value = project.preferredCli ?? '';
863 | model.value = project.selectedModel ?? '';
864 | useCcr.value = project.useCcr ?? false;
865 | enableChromeMcp.value = project.enableChromeMcp !== false;
866 |
867 | // Ensure a default session exists for the new project
868 | const engineName =
869 | (selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm') || 'claude';
870 | await sessions.ensureDefaultSession(project.id, engineName);
871 |
872 | // Reconnect SSE and load session history
873 | if (sessions.selectedSessionId.value) {
874 | server.openEventSource();
875 | await loadSessionHistory(sessions.selectedSessionId.value);
876 | }
877 | }
878 | }
879 | } finally {
880 | isPickingDirectory.value = false;
881 | closeMenus();
882 | }
883 | }
884 |
885 | async function handleSaveSettings(): Promise<void> {
886 | const project = projects.selectedProject.value;
887 | if (!project) return;
888 |
889 | // Capture previous CLI to detect changes
890 | const previousCli = project.preferredCli ?? '';
891 |
892 | isSavingPreference.value = true;
893 | try {
894 | // Use normalized model to ensure valid value is saved
895 | const normalizedModel = getNormalizedModel();
896 | // Only save CCR if Claude CLI is selected
897 | const normalizedCcr = selectedCli.value === 'claude' ? useCcr.value : false;
898 | await projects.saveProjectPreference(
899 | selectedCli.value,
900 | normalizedModel,
901 | normalizedCcr,
902 | enableChromeMcp.value,
903 | );
904 | // Sync local state with normalized values
905 | model.value = normalizedModel;
906 | useCcr.value = normalizedCcr;
907 |
908 | // If CLI changed, create a new empty session with the new CLI
909 | const cliChanged = previousCli !== selectedCli.value;
910 | if (cliChanged && selectedCli.value) {
911 | const engineName = selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm';
912 |
913 | // Include codex config if using codex engine
914 | const optionsConfig =
915 | engineName === 'codex'
916 | ? {
917 | codexConfig: {
918 | reasoningEffort: getNormalizedReasoningEffort(),
919 | },
920 | }
921 | : undefined;
922 |
923 | const session = await sessions.createSession(project.id, {
924 | engineName,
925 | name: `Session ${sessions.sessions.value.length + 1}`,
926 | optionsConfig,
927 | });
928 |
929 | // Guard: only clear messages if the new session is still selected
930 | // This prevents clearing messages if user switched during createSession await
931 | if (session && sessions.selectedSessionId.value === session.id) {
932 | chat.setMessages([]);
933 | }
934 | }
935 | } finally {
936 | isSavingPreference.value = false;
937 | closeMenus();
938 | }
939 | }
940 |
941 | // =============================================================================
942 | // View Navigation
943 | // =============================================================================
944 |
945 | /**
946 | * Handle session selection from sessions list and navigate to chat view.
947 | * Supports cross-project selection: if the selected session belongs to a different
948 | * project, the project context will be switched automatically.
949 | */
950 | async function handleSessionSelectAndNavigate(sessionId: string): Promise<void> {
951 | // Only clear request state when switching to a DIFFERENT session
952 | // If re-entering the same session, preserve the running state
953 | // (e.g., user exits to list and comes back while request is still running)
954 | const isSameSession = sessions.selectedSessionId.value === sessionId;
955 | if (!isSameSession) {
956 | clearRequestState();
957 | }
958 |
959 | // Find the session's projectId from allSessions, fallback to API if not found
960 | const targetProjectId =
961 | sessions.allSessions.value.find((s) => s.id === sessionId)?.projectId ??
962 | (await sessions.getSession(sessionId))?.projectId;
963 |
964 | if (!targetProjectId) {
965 | console.warn('[AgentChat] Unable to resolve projectId for session:', sessionId);
966 | return;
967 | }
968 |
969 | // If the session belongs to a different project, switch project context first
970 | if (projects.selectedProjectId.value !== targetProjectId) {
971 | // Clear sessions before switching to prevent stale data mixing
972 | sessions.clearSessions();
973 | projects.selectedProjectId.value = targetProjectId;
974 | await projects.handleProjectChanged();
975 |
976 | // Guard: abort if user switched to a different project during await
977 | if (projects.selectedProjectId.value !== targetProjectId) {
978 | return;
979 | }
980 |
981 | // Sync local UI state with the new project's preferences
982 | const project = projects.selectedProject.value;
983 | if (project) {
984 | selectedCli.value = project.preferredCli ?? '';
985 | model.value = project.selectedModel ?? '';
986 | useCcr.value = project.useCcr ?? false;
987 | enableChromeMcp.value = project.enableChromeMcp !== false;
988 | }
989 |
990 | // Fetch sessions for the new project
991 | await sessions.fetchSessions(targetProjectId);
992 |
993 | // Guard again after fetchSessions
994 | if (projects.selectedProjectId.value !== targetProjectId) {
995 | return;
996 | }
997 | }
998 |
999 | await sessions.selectSession(sessionId);
1000 |
1001 | // Guard against stale navigation if user switched to a different session during await
1002 | if (sessions.selectedSessionId.value !== sessionId) {
1003 | return;
1004 | }
1005 |
1006 | viewRoute.goToChat(sessionId);
1007 |
1008 | // Open SSE and load history when entering chat view
1009 | server.openEventSource();
1010 | await loadSessionHistory(sessionId);
1011 | }
1012 |
1013 | /**
1014 | * Create a new session and navigate to chat view.
1015 | */
1016 | async function handleNewSessionAndNavigate(): Promise<void> {
1017 | if (!projects.selectedProjectId.value) return;
1018 |
1019 | // Clear previous state before creating new session
1020 | clearRequestState();
1021 |
1022 | const engineName =
1023 | (selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm') || 'claude';
1024 | const optionsConfig =
1025 | engineName === 'codex'
1026 | ? {
1027 | codexConfig: {
1028 | reasoningEffort: getNormalizedReasoningEffort(),
1029 | },
1030 | }
1031 | : undefined;
1032 |
1033 | const session = await sessions.createSession(projects.selectedProjectId.value, {
1034 | engineName,
1035 | name: `Session ${sessions.sessions.value.length + 1}`,
1036 | optionsConfig,
1037 | });
1038 |
1039 | // Guard against stale navigation if user switched during createSession await
1040 | if (session && sessions.selectedSessionId.value === session.id) {
1041 | chat.setMessages([]);
1042 | viewRoute.goToChat(session.id);
1043 |
1044 | // Open SSE for new session
1045 | server.openEventSource();
1046 | }
1047 | }
1048 |
1049 | /**
1050 | * Navigate back to sessions list.
1051 | */
1052 | function handleBackToSessions(): void {
1053 | viewRoute.goToSessions();
1054 | }
1055 |
1056 | // =============================================================================
1057 | // Web Editor Selection Context
1058 | // =============================================================================
1059 |
1060 | /**
1061 | * Build instruction with web editor selection context prepended.
1062 | * This provides AI with element context when user asks to modify selected element.
1063 | *
1064 | * Format:
1065 | * ```
1066 | * [WebEditorSelectionContext]
1067 | * pageUrl: <pageUrl>
1068 | * tagName: <tagName>
1069 | * label: <label>
1070 | * selectors: [<up to 3>]
1071 | * fingerprint: <fingerprint>
1072 | *
1073 | * [UserRequest]
1074 | * <user original input>
1075 | * ```
1076 | *
1077 | * @param userInput - The user's original input text
1078 | * @returns Instruction with context prepended, or original input if no selection
1079 | */
1080 | function buildInstructionWithSelectionContext(userInput: string): string {
1081 | const selection = webEditorTxState.selectedElement.value;
1082 | const txState = webEditorTxState.txState.value;
1083 | const selectionPageUrl = webEditorTxState.selectionPageUrl.value;
1084 |
1085 | // No selection = return original input
1086 | if (!selection) {
1087 | return userInput;
1088 | }
1089 |
1090 | // Build context lines
1091 | const contextLines: string[] = ['[WebEditorSelectionContext]'];
1092 |
1093 | // Page URL - prefer selection's pageUrl (more recent), fall back to txState
1094 | const pageUrl = selectionPageUrl || txState?.pageUrl;
1095 | if (pageUrl) {
1096 | contextLines.push(`pageUrl: ${pageUrl}`);
1097 | }
1098 |
1099 | // Element key for stable identification
1100 | if (selection.elementKey) {
1101 | contextLines.push(`elementKey: ${selection.elementKey}`);
1102 | }
1103 |
1104 | // Element info
1105 | contextLines.push(`tagName: ${selection.tagName || 'unknown'}`);
1106 | contextLines.push(`label: ${selection.label || selection.fullLabel || 'unknown'}`);
1107 |
1108 | // Selectors (up to 3)
1109 | const selectors = selection.locator?.selectors ?? [];
1110 | const topSelectors = selectors.slice(0, 3);
1111 | if (topSelectors.length > 0) {
1112 | contextLines.push(`selectors: [${topSelectors.map((s) => `"${s}"`).join(', ')}]`);
1113 | }
1114 |
1115 | // Fingerprint for similarity matching
1116 | if (selection.locator?.fingerprint) {
1117 | contextLines.push(`fingerprint: ${selection.locator.fingerprint}`);
1118 | }
1119 |
1120 | // Combine context with user request
1121 | return `${contextLines.join('\n')}\n\n[UserRequest]\n${userInput}`;
1122 | }
1123 |
1124 | // Attachment handlers
1125 | function handleAttachmentAdd(): void {
1126 | // Create and click a hidden file input
1127 | const input = document.createElement('input');
1128 | input.type = 'file';
1129 | input.accept = 'image/*';
1130 | input.multiple = true;
1131 | input.onchange = (e) => attachments.handleFileSelect(e);
1132 | input.click();
1133 | }
1134 |
1135 | // Send handler
1136 | async function handleSend(): Promise<void> {
1137 | const dbSessionId = sessions.selectedSessionId.value;
1138 | if (!dbSessionId) {
1139 | chat.errorMessage.value = 'No session selected.';
1140 | return;
1141 | }
1142 |
1143 | // Capture input before clearing for preview update
1144 | const messageText = chat.input.value.trim();
1145 | if (!messageText) return;
1146 |
1147 | // Check if user has selected an element in web editor
1148 | const selection = webEditorTxState.selectedElement.value;
1149 | const txState = webEditorTxState.txState.value;
1150 | const selectionPageUrl = webEditorTxState.selectionPageUrl.value;
1151 |
1152 | // Capture selection info before sending (for clear after success)
1153 | const selectionTabId = webEditorTxState.tabId.value;
1154 | const selectionElementKey = selection?.elementKey ?? null;
1155 |
1156 | // When a web editor element is selected, store structured metadata on the user message
1157 | // so the thread header can render as a chip (same style as "Web editor apply")
1158 | const selectionClientMeta = selection
1159 | ? {
1160 | kind: 'web_editor_apply_single' as const,
1161 | pageUrl: selectionPageUrl || txState?.pageUrl || 'unknown',
1162 | elementCount: 1,
1163 | elementLabels: [
1164 | selection.label || selection.fullLabel || selection.tagName || 'selected element',
1165 | ],
1166 | }
1167 | : undefined;
1168 |
1169 | // Build instruction with web editor selection context (if any)
1170 | // The UI will show the original messageText, but the actual instruction
1171 | // sent to the server will include element context for AI to understand
1172 | const instructionWithContext = buildInstructionWithSelectionContext(messageText);
1173 |
1174 | // Use getAttachments() to strip previewUrl and avoid payload bloat
1175 | chat.attachments.value = attachments.getAttachments() ?? [];
1176 |
1177 | // Session-level config is now used by backend; no need to pass cliPreference/model
1178 | // For selection context messages, use the user's input as displayText
1179 | // so the chip shows meaningful content instead of a generic label
1180 | await chat.send({
1181 | projectId: projects.selectedProjectId.value || undefined,
1182 | dbSessionId,
1183 | // Pass the context-enriched instruction to be sent to server
1184 | instruction: instructionWithContext,
1185 | // Attach metadata only when selection context exists
1186 | // Use user's original message as displayText for better UX
1187 | displayText: selection ? messageText : undefined,
1188 | clientMeta: selectionClientMeta,
1189 | });
1190 |
1191 | // Clear web editor selection after successful send
1192 | // This "consumes" the selection context so it won't be re-injected in next message
1193 | if (selectionElementKey && selectionTabId) {
1194 | // Check if user has selected a DIFFERENT element during the loading period
1195 | // Compare both elementKey AND tabId to handle cross-tab scenarios
1196 | // (elementKey like "div#app" is not unique across tabs/pages)
1197 | const currentElementKey = webEditorTxState.selectedElement.value?.elementKey ?? null;
1198 | const currentTabId = webEditorTxState.tabId.value;
1199 |
1200 | const isSameSelection =
1201 | currentElementKey === selectionElementKey && currentTabId === selectionTabId;
1202 |
1203 | if (!isSameSelection && currentElementKey !== null) {
1204 | // User selected a new element (or switched tab) during send - preserve it, don't clear
1205 | } else {
1206 | // Same element or already deselected - proceed with clear
1207 | // Try to clear via message (web-editor may be open)
1208 | chrome.runtime
1209 | .sendMessage({
1210 | type: BACKGROUND_MESSAGE_TYPES.WEB_EDITOR_CLEAR_SELECTION,
1211 | payload: { tabId: selectionTabId },
1212 | })
1213 | .then((response: { success: boolean } | undefined) => {
1214 | // If web-editor didn't respond (closed/not active), clear local state
1215 | // Use captured selectionTabId/selectionElementKey to avoid clearing new selection
1216 | if (!response?.success) {
1217 | clearLocalSelectionState(selectionTabId, selectionElementKey);
1218 | }
1219 | // If success, web-editor will broadcast null selection which will clear our state
1220 | })
1221 | .catch(() => {
1222 | // Message failed - clear sidepanel local state directly
1223 | clearLocalSelectionState(selectionTabId, selectionElementKey);
1224 | });
1225 | }
1226 | }
1227 |
1228 | // Update session preview with first user message (if not already set)
1229 | // Note: Use original messageText, not the context-enriched version
1230 | // Include previewMeta for special chip rendering in session list
1231 | sessions.updateSessionPreview(
1232 | dbSessionId,
1233 | messageText,
1234 | selectionClientMeta
1235 | ? {
1236 | displayText: messageText,
1237 | clientMeta: selectionClientMeta,
1238 | fullContent: instructionWithContext,
1239 | }
1240 | : undefined,
1241 | );
1242 |
1243 | attachments.clearAttachments();
1244 | }
1245 |
1246 | /**
1247 | * Clear sidepanel local selection state.
1248 | * Used when web-editor is closed or unreachable.
1249 | *
1250 | * @param expectedTabId - The tab ID that was selected at send time
1251 | * @param expectedElementKey - The element key that was selected at send time
1252 | */
1253 | function clearLocalSelectionState(expectedTabId: number, expectedElementKey: string): void {
1254 | // Double-check we're still on the same selection to avoid clearing new selection
1255 | const currentTabId = webEditorTxState.tabId.value;
1256 | const currentElementKey = webEditorTxState.selectedElement.value?.elementKey ?? null;
1257 |
1258 | // Only clear if still pointing to the same selection (or already cleared)
1259 | const shouldClear =
1260 | currentElementKey === null ||
1261 | (currentTabId === expectedTabId && currentElementKey === expectedElementKey);
1262 |
1263 | if (!shouldClear) {
1264 | // User switched to a different selection - don't clear
1265 | return;
1266 | }
1267 |
1268 | // Clear the reactive state
1269 | webEditorTxState.selectedElement.value = null;
1270 | webEditorTxState.selectionPageUrl.value = null;
1271 |
1272 | // Clear session storage to prevent "revival" on refresh/tab switch
1273 | if (expectedTabId) {
1274 | const storageKey = `web-editor-v2-selection-${expectedTabId}`;
1275 | chrome.storage.session.remove(storageKey).catch(() => {
1276 | // Ignore storage errors
1277 | });
1278 | }
1279 | }
1280 |
1281 | // Initialize
1282 | onMounted(async () => {
1283 | // Initialize theme
1284 | await themeState.initTheme();
1285 |
1286 | // Load open project preference
1287 | await openProjectPreference.loadDefaultTarget();
1288 |
1289 | // Load input preferences (fake caret, etc.)
1290 | await inputPreferences.init();
1291 |
1292 | // Initialize server
1293 | await server.initialize();
1294 |
1295 | if (server.isServerReady.value) {
1296 | // Ensure default project exists and load projects
1297 | await projects.ensureDefaultProject();
1298 | await projects.fetchProjects();
1299 |
1300 | // Load all sessions across all projects for the global sessions list view
1301 | await sessions.fetchAllSessions();
1302 |
1303 | // Load selected project or use first one
1304 | await projects.loadSelectedProjectId();
1305 | const hasValidSelection =
1306 | projects.selectedProjectId.value &&
1307 | projects.projects.value.some((p) => p.id === projects.selectedProjectId.value);
1308 |
1309 | if (!hasValidSelection && projects.projects.value.length > 0) {
1310 | projects.selectedProjectId.value = projects.projects.value[0].id;
1311 | await projects.saveSelectedProjectId();
1312 | }
1313 |
1314 | // Load settings and sessions
1315 | if (projects.selectedProjectId.value) {
1316 | const project = projects.selectedProject.value;
1317 | if (project) {
1318 | selectedCli.value = project.preferredCli ?? '';
1319 | model.value = project.selectedModel ?? '';
1320 | useCcr.value = project.useCcr ?? false;
1321 | enableChromeMcp.value = project.enableChromeMcp !== false;
1322 | }
1323 |
1324 | // Load sessions for the project
1325 | await sessions.loadSelectedSessionId();
1326 | await sessions.fetchSessions(projects.selectedProjectId.value);
1327 |
1328 | // Parse URL parameters to determine initial view
1329 | // Note: This is called after fetchSessions so we can verify the session exists
1330 | const initialRoute = viewRoute.initFromUrl();
1331 |
1332 | // Handle deep link: URL specifies session to open directly (e.g., from Apply)
1333 | // Support cross-project sessions by checking allSessions first
1334 | if (initialRoute.view === 'chat' && initialRoute.sessionId) {
1335 | const targetSession =
1336 | sessions.allSessions.value.find((s) => s.id === initialRoute.sessionId) ??
1337 | sessions.sessions.value.find((s) => s.id === initialRoute.sessionId);
1338 |
1339 | if (targetSession) {
1340 | // Use handleSessionSelectAndNavigate to handle cross-project switching
1341 | await handleSessionSelectAndNavigate(targetSession.id);
1342 | } else {
1343 | // Session doesn't exist in any project, fall back to sessions list
1344 | viewRoute.goToSessions();
1345 | }
1346 | }
1347 |
1348 | // Ensure a default session exists (for new users)
1349 | // Note: This won't fetch sessions again since we already did above
1350 | await sessions.ensureDefaultSession(
1351 | projects.selectedProjectId.value,
1352 | (selectedCli.value as 'claude' | 'codex' | 'cursor' | 'qwen' | 'glm') || 'claude',
1353 | );
1354 |
1355 | // Only open SSE and load history if we're in chat view with a valid session
1356 | if (viewRoute.isChatView.value && sessions.selectedSessionId.value) {
1357 | server.openEventSource();
1358 | await loadSessionHistory(sessions.selectedSessionId.value);
1359 | }
1360 | }
1361 | }
1362 | });
1363 |
1364 | // Watch for server ready
1365 | watch(
1366 | () => server.isServerReady.value,
1367 | async (ready) => {
1368 | if (ready && projects.projects.value.length === 0) {
1369 | await projects.ensureDefaultProject();
1370 | await projects.fetchProjects();
1371 |
1372 | // Also fetch all sessions for the global sessions list
1373 | await sessions.fetchAllSessions();
1374 |
1375 | const hasValidSelection =
1376 | projects.selectedProjectId.value &&
1377 | projects.projects.value.some((p) => p.id === projects.selectedProjectId.value);
1378 |
1379 | if (!hasValidSelection && projects.projects.value.length > 0) {
1380 | projects.selectedProjectId.value = projects.projects.value[0].id;
1381 | await projects.saveSelectedProjectId();
1382 | }
1383 | }
1384 | },
1385 | );
1386 |
1387 | // Close menus on Escape key
1388 | const handleEscape = (e: KeyboardEvent) => {
1389 | if (e.key === 'Escape') {
1390 | closeMenus();
1391 | }
1392 | };
1393 |
1394 | onMounted(() => {
1395 | document.addEventListener('keydown', handleEscape);
1396 | });
1397 |
1398 | onUnmounted(() => {
1399 | document.removeEventListener('keydown', handleEscape);
1400 | });
1401 | </script>
1402 |
```