forked from sanbuphy/learn-coding-agent
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathwrapper.tsx
More file actions
336 lines (331 loc) · 48.3 KB
/
wrapper.tsx
File metadata and controls
336 lines (331 loc) · 48.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
/**
* The `.call()` override — thin adapter between `ToolUseContext` and
* `bindSessionContext`. Spread into the MCP tool object in `client.ts`
* (same pattern as Chrome's rendering overrides, plus `.call()`).
*
* The wrapper-closure logic (build overrides fresh, lock gate, permission
* merge, screenshot stash) lives in `@ant/computer-use-mcp`'s
* `bindSessionContext`. This file binds it once per process,
* caches the dispatcher, and updates a per-call ref for the pieces of
* `ToolUseContext` that vary per-call (`abortController`, `setToolJSX`,
* `sendOSNotification`). AppState accessors are read through the ref too —
* they're likely stable but we don't depend on that.
*
* External callers reach this via the lazy require thunk in `client.ts`, gated
* on `feature('CHICAGO_MCP')`. Runtime enablement is controlled by the
* GrowthBook gate `tengu_malort_pedway` (see gates.ts).
*/
import { bindSessionContext, type ComputerUseSessionContext, type CuCallToolResult, type CuPermissionRequest, type CuPermissionResponse, DEFAULT_GRANT_FLAGS, type ScreenshotDims } from '@ant/computer-use-mcp';
import * as React from 'react';
import { getSessionId } from '../../bootstrap/state.js';
import { ComputerUseApproval } from '../../components/permissions/ComputerUseApproval/ComputerUseApproval.js';
import type { Tool, ToolUseContext } from '../../Tool.js';
import { logForDebugging } from '../debug.js';
import { checkComputerUseLock, tryAcquireComputerUseLock } from './computerUseLock.js';
import { registerEscHotkey } from './escHotkey.js';
import { getChicagoCoordinateMode } from './gates.js';
import { getComputerUseHostAdapter } from './hostAdapter.js';
import { getComputerUseMCPRenderingOverrides } from './toolRendering.js';
type CallOverride = Pick<Tool, 'call'>['call'];
type Binding = {
ctx: ComputerUseSessionContext;
dispatch: (name: string, args: unknown) => Promise<CuCallToolResult>;
};
/**
* Cached binding — built on first `.call()`, reused for process lifetime.
* The dispatcher's closure-held screenshot blob persists across calls.
*
* `currentToolUseContext` is updated on every call. Every getter/callback in
* `ctx` reads through it, so the per-call pieces (`abortController`,
* `setToolJSX`, `sendOSNotification`) are always current.
*
* Module-level `let` is a deliberate exception to the no-module-scope-state
* rule (src/CLAUDE.md): the dispatcher closure must persist across calls so
* its internal screenshot blob survives, but `ToolUseContext` is per-call.
* Tests will need to either inject the cache or run serially.
*/
let binding: Binding | undefined;
let currentToolUseContext: ToolUseContext | undefined;
function tuc(): ToolUseContext {
// Safe: `binding` is only populated when `currentToolUseContext` is set.
// Called only from within `ctx` callbacks, which only fire during dispatch.
return currentToolUseContext!;
}
function formatLockHeld(holder: string): string {
return `Computer use is in use by another Claude session (${holder.slice(0, 8)}…). Wait for that session to finish or run /exit there.`;
}
export function buildSessionContext(): ComputerUseSessionContext {
return {
// ── Read state fresh via the per-call ref ─────────────────────────────
getAllowedApps: () => tuc().getAppState().computerUseMcpState?.allowedApps ?? [],
getGrantFlags: () => tuc().getAppState().computerUseMcpState?.grantFlags ?? DEFAULT_GRANT_FLAGS,
// cc-2 has no Settings page for user-denied apps yet.
getUserDeniedBundleIds: () => [],
getSelectedDisplayId: () => tuc().getAppState().computerUseMcpState?.selectedDisplayId,
getDisplayPinnedByModel: () => tuc().getAppState().computerUseMcpState?.displayPinnedByModel ?? false,
getDisplayResolvedForApps: () => tuc().getAppState().computerUseMcpState?.displayResolvedForApps,
getLastScreenshotDims: (): ScreenshotDims | undefined => {
const d = tuc().getAppState().computerUseMcpState?.lastScreenshotDims;
return d ? {
...d,
displayId: d.displayId ?? 0,
originX: d.originX ?? 0,
originY: d.originY ?? 0
} : undefined;
},
// ── Write-backs ────────────────────────────────────────────────────────
// `setToolJSX` is guaranteed present — the gate in `main.tsx` excludes
// non-interactive sessions. The package's `_dialogSignal` (tool-finished
// dismissal) is irrelevant here: `setToolJSX` blocks the tool call, so
// the dialog can't outlive it. Ctrl+C is what matters, and
// `runPermissionDialog` wires that from the per-call ref's abortController.
onPermissionRequest: (req, _dialogSignal) => runPermissionDialog(req),
// Package does the merge (dedupe + truthy-only flags). We just persist.
onAllowedAppsChanged: (apps, flags) => tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
const prevApps = cu?.allowedApps;
const prevFlags = cu?.grantFlags;
const sameApps = prevApps?.length === apps.length && apps.every((a, i) => prevApps[i]?.bundleId === a.bundleId);
const sameFlags = prevFlags?.clipboardRead === flags.clipboardRead && prevFlags?.clipboardWrite === flags.clipboardWrite && prevFlags?.systemKeyCombos === flags.systemKeyCombos;
return sameApps && sameFlags ? prev : {
...prev,
computerUseMcpState: {
...cu,
allowedApps: [...apps],
grantFlags: flags
}
};
}),
onAppsHidden: ids => {
if (ids.length === 0) return;
tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
const existing = cu?.hiddenDuringTurn;
if (existing && ids.every(id => existing.has(id))) return prev;
return {
...prev,
computerUseMcpState: {
...cu,
hiddenDuringTurn: new Set([...(existing ?? []), ...ids])
}
};
});
},
// Resolver writeback only fires under a pin when Swift fell back to main
// (pinned display unplugged) — the pin is semantically dead, so clear it
// and the app-set key so the chase chain runs next time. When autoResolve
// was true, onDisplayResolvedForApps re-sets the key in the same tick.
onResolvedDisplayUpdated: id => tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
if (cu?.selectedDisplayId === id && !cu.displayPinnedByModel && cu.displayResolvedForApps === undefined) {
return prev;
}
return {
...prev,
computerUseMcpState: {
...cu,
selectedDisplayId: id,
displayPinnedByModel: false,
displayResolvedForApps: undefined
}
};
}),
// switch_display(name) pins; switch_display("auto") unpins and clears the
// app-set key so the next screenshot auto-resolves fresh.
onDisplayPinned: id => tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
const pinned = id !== undefined;
const nextResolvedFor = pinned ? cu?.displayResolvedForApps : undefined;
if (cu?.selectedDisplayId === id && cu?.displayPinnedByModel === pinned && cu?.displayResolvedForApps === nextResolvedFor) {
return prev;
}
return {
...prev,
computerUseMcpState: {
...cu,
selectedDisplayId: id,
displayPinnedByModel: pinned,
displayResolvedForApps: nextResolvedFor
}
};
}),
onDisplayResolvedForApps: key => tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
if (cu?.displayResolvedForApps === key) return prev;
return {
...prev,
computerUseMcpState: {
...cu,
displayResolvedForApps: key
}
};
}),
onScreenshotCaptured: dims => tuc().setAppState(prev => {
const cu = prev.computerUseMcpState;
const p = cu?.lastScreenshotDims;
return p?.width === dims.width && p?.height === dims.height && p?.displayWidth === dims.displayWidth && p?.displayHeight === dims.displayHeight && p?.displayId === dims.displayId && p?.originX === dims.originX && p?.originY === dims.originY ? prev : {
...prev,
computerUseMcpState: {
...cu,
lastScreenshotDims: dims
}
};
}),
// ── Lock — async, direct file-lock calls ───────────────────────────────
// No `lockHolderForGate` dance: the package's gate is async now. It
// awaits `checkCuLock`, and on `holder: undefined` + non-deferring tool
// awaits `acquireCuLock`. `defersLockAcquire` is the PACKAGE's set —
// the local copy is gone.
checkCuLock: async () => {
const c = await checkComputerUseLock();
switch (c.kind) {
case 'free':
return {
holder: undefined,
isSelf: false
};
case 'held_by_self':
return {
holder: getSessionId(),
isSelf: true
};
case 'blocked':
return {
holder: c.by,
isSelf: false
};
}
},
// Called only when checkCuLock returned `holder: undefined`. The O_EXCL
// acquire is atomic — if another process grabbed it in the gap (rare),
// throw so the tool fails instead of proceeding without the lock.
// `fresh: false` (re-entrant) shouldn't happen given check said free,
// but is possible under parallel tool-use interleaving — don't spam the
// notification in that case.
acquireCuLock: async () => {
const r = await tryAcquireComputerUseLock();
if (r.kind === 'blocked') {
throw new Error(formatLockHeld(r.by));
}
if (r.fresh) {
// Global Escape → abort. Consumes the event (PI defense — prompt
// injection can't dismiss dialogs with Escape). The CGEventTap's
// CFRunLoopSource is processed by the drainRunLoop pump, so this
// holds a pump retain until unregisterEscHotkey() in cleanup.ts.
const escRegistered = registerEscHotkey(() => {
logForDebugging('[cu-esc] user escape, aborting turn');
tuc().abortController.abort();
});
tuc().sendOSNotification?.({
message: escRegistered ? 'Claude is using your computer · press Esc to stop' : 'Claude is using your computer · press Ctrl+C to stop',
notificationType: 'computer_use_enter'
});
}
},
formatLockHeldMessage: formatLockHeld
};
}
function getOrBind(): Binding {
if (binding) return binding;
const ctx = buildSessionContext();
binding = {
ctx,
dispatch: bindSessionContext(getComputerUseHostAdapter(), getChicagoCoordinateMode(), ctx)
};
return binding;
}
/**
* Returns the full override object for a single `mcp__computer-use__{toolName}`
* tool: rendering overrides from `toolRendering.tsx` plus a `.call()` that
* dispatches through the cached binder.
*/
type ComputerUseMCPToolOverrides = ReturnType<typeof getComputerUseMCPRenderingOverrides> & {
call: CallOverride;
};
export function getComputerUseMCPToolOverrides(toolName: string): ComputerUseMCPToolOverrides {
const call: CallOverride = async (args, context: ToolUseContext) => {
currentToolUseContext = context;
const {
dispatch
} = getOrBind();
const {
telemetry,
...result
} = await dispatch(toolName, args);
if (telemetry?.error_kind) {
logForDebugging(`[Computer Use MCP] ${toolName} error_kind=${telemetry.error_kind}`);
}
// MCP content blocks → Anthropic API blocks. CU only produces text and
// pre-sized JPEG (executor.ts computeTargetDims → targetImageSize), so
// unlike the generic MCP path there's no resize needed — the MCP image
// shape just maps to the API's base64-source shape. The package's result
// type admits audio/resource too, but CU's handleToolCall never emits
// those; the fallthrough coerces them to empty text.
const data = Array.isArray(result.content) ? result.content.map(item => item.type === 'image' ? {
type: 'image' as const,
source: {
type: 'base64' as const,
media_type: item.mimeType ?? 'image/jpeg',
data: item.data
}
} : {
type: 'text' as const,
text: item.type === 'text' ? item.text : ''
}) : result.content;
return {
data
};
};
return {
...getComputerUseMCPRenderingOverrides(toolName),
call
};
}
/**
* Render the approval dialog mid-call via `setToolJSX` + `Promise`, wait for
* the user. Mirrors `spawnMultiAgent.ts:419-436` (the `It2SetupPrompt` pattern).
*
* The merge-into-AppState that used to live here (dedupe + truthy-only flags)
* is now in the package's `bindSessionContext` → `onAllowedAppsChanged`.
*/
async function runPermissionDialog(req: CuPermissionRequest): Promise<CuPermissionResponse> {
const context = tuc();
const setToolJSX = context.setToolJSX;
if (!setToolJSX) {
// Shouldn't happen — main.tsx gate excludes non-interactive. Fail safe.
return {
granted: [],
denied: [],
flags: DEFAULT_GRANT_FLAGS
};
}
try {
return await new Promise<CuPermissionResponse>((resolve, reject) => {
const signal = context.abortController.signal;
// If already aborted, addEventListener won't fire — reject now so the
// promise doesn't hang waiting for a user who Ctrl+C'd.
if (signal.aborted) {
reject(new Error('Computer Use permission dialog aborted'));
return;
}
const onAbort = (): void => {
signal.removeEventListener('abort', onAbort);
reject(new Error('Computer Use permission dialog aborted'));
};
signal.addEventListener('abort', onAbort);
setToolJSX({
jsx: React.createElement(ComputerUseApproval, {
request: req,
onDone: (resp: CuPermissionResponse) => {
signal.removeEventListener('abort', onAbort);
resolve(resp);
}
}),
shouldHidePromptInput: true
});
});
} finally {
setToolJSX(null);
}
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["bindSessionContext","ComputerUseSessionContext","CuCallToolResult","CuPermissionRequest","CuPermissionResponse","DEFAULT_GRANT_FLAGS","ScreenshotDims","React","getSessionId","ComputerUseApproval","Tool","ToolUseContext","logForDebugging","checkComputerUseLock","tryAcquireComputerUseLock","registerEscHotkey","getChicagoCoordinateMode","getComputerUseHostAdapter","getComputerUseMCPRenderingOverrides","CallOverride","Pick","Binding","ctx","dispatch","name","args","Promise","binding","currentToolUseContext","tuc","formatLockHeld","holder","slice","buildSessionContext","getAllowedApps","getAppState","computerUseMcpState","allowedApps","getGrantFlags","grantFlags","getUserDeniedBundleIds","getSelectedDisplayId","selectedDisplayId","getDisplayPinnedByModel","displayPinnedByModel","getDisplayResolvedForApps","displayResolvedForApps","getLastScreenshotDims","d","lastScreenshotDims","displayId","originX","originY","undefined","onPermissionRequest","req","_dialogSignal","runPermissionDialog","onAllowedAppsChanged","apps","flags","setAppState","prev","cu","prevApps","prevFlags","sameApps","length","every","a","i","bundleId","sameFlags","clipboardRead","clipboardWrite","systemKeyCombos","onAppsHidden","ids","existing","hiddenDuringTurn","id","has","Set","onResolvedDisplayUpdated","onDisplayPinned","pinned","nextResolvedFor","onDisplayResolvedForApps","key","onScreenshotCaptured","dims","p","width","height","displayWidth","displayHeight","checkCuLock","c","kind","isSelf","by","acquireCuLock","r","Error","fresh","escRegistered","abortController","abort","sendOSNotification","message","notificationType","formatLockHeldMessage","getOrBind","ComputerUseMCPToolOverrides","ReturnType","call","getComputerUseMCPToolOverrides","toolName","context","telemetry","result","error_kind","data","Array","isArray","content","map","item","type","const","source","media_type","mimeType","text","setToolJSX","granted","denied","resolve","reject","signal","aborted","onAbort","removeEventListener","addEventListener","jsx","createElement","request","onDone","resp","shouldHidePromptInput"],"sources":["wrapper.tsx"],"sourcesContent":["/**\n * The `.call()` override — thin adapter between `ToolUseContext` and\n * `bindSessionContext`. Spread into the MCP tool object in `client.ts`\n * (same pattern as Chrome's rendering overrides, plus `.call()`).\n *\n * The wrapper-closure logic (build overrides fresh, lock gate, permission\n * merge, screenshot stash) lives in `@ant/computer-use-mcp`'s\n * `bindSessionContext`. This file binds it once per process,\n * caches the dispatcher, and updates a per-call ref for the pieces of\n * `ToolUseContext` that vary per-call (`abortController`, `setToolJSX`,\n * `sendOSNotification`). AppState accessors are read through the ref too —\n * they're likely stable but we don't depend on that.\n *\n * External callers reach this via the lazy require thunk in `client.ts`, gated\n * on `feature('CHICAGO_MCP')`. Runtime enablement is controlled by the\n * GrowthBook gate `tengu_malort_pedway` (see gates.ts).\n */\n\nimport {\n  bindSessionContext,\n  type ComputerUseSessionContext,\n  type CuCallToolResult,\n  type CuPermissionRequest,\n  type CuPermissionResponse,\n  DEFAULT_GRANT_FLAGS,\n  type ScreenshotDims,\n} from '@ant/computer-use-mcp'\nimport * as React from 'react'\nimport { getSessionId } from '../../bootstrap/state.js'\nimport { ComputerUseApproval } from '../../components/permissions/ComputerUseApproval/ComputerUseApproval.js'\nimport type { Tool, ToolUseContext } from '../../Tool.js'\nimport { logForDebugging } from '../debug.js'\nimport {\n  checkComputerUseLock,\n  tryAcquireComputerUseLock,\n} from './computerUseLock.js'\nimport { registerEscHotkey } from './escHotkey.js'\nimport { getChicagoCoordinateMode } from './gates.js'\nimport { getComputerUseHostAdapter } from './hostAdapter.js'\nimport { getComputerUseMCPRenderingOverrides } from './toolRendering.js'\n\ntype CallOverride = Pick<Tool, 'call'>['call']\n\ntype Binding = {\n  ctx: ComputerUseSessionContext\n  dispatch: (name: string, args: unknown) => Promise<CuCallToolResult>\n}\n\n/**\n * Cached binding — built on first `.call()`, reused for process lifetime.\n * The dispatcher's closure-held screenshot blob persists across calls.\n *\n * `currentToolUseContext` is updated on every call. Every getter/callback in\n * `ctx` reads through it, so the per-call pieces (`abortController`,\n * `setToolJSX`, `sendOSNotification`) are always current.\n *\n * Module-level `let` is a deliberate exception to the no-module-scope-state\n * rule (src/CLAUDE.md): the dispatcher closure must persist across calls so\n * its internal screenshot blob survives, but `ToolUseContext` is per-call.\n * Tests will need to either inject the cache or run serially.\n */\nlet binding: Binding | undefined\nlet currentToolUseContext: ToolUseContext | undefined\n\nfunction tuc(): ToolUseContext {\n  // Safe: `binding` is only populated when `currentToolUseContext` is set.\n  // Called only from within `ctx` callbacks, which only fire during dispatch.\n  return currentToolUseContext!\n}\n\nfunction formatLockHeld(holder: string): string {\n  return `Computer use is in use by another Claude session (${holder.slice(0, 8)}…). Wait for that session to finish or run /exit there.`\n}\n\nexport function buildSessionContext(): ComputerUseSessionContext {\n  return {\n    // ── Read state fresh via the per-call ref ─────────────────────────────\n    getAllowedApps: () =>\n      tuc().getAppState().computerUseMcpState?.allowedApps ?? [],\n    getGrantFlags: () =>\n      tuc().getAppState().computerUseMcpState?.grantFlags ??\n      DEFAULT_GRANT_FLAGS,\n    // cc-2 has no Settings page for user-denied apps yet.\n    getUserDeniedBundleIds: () => [],\n    getSelectedDisplayId: () =>\n      tuc().getAppState().computerUseMcpState?.selectedDisplayId,\n    getDisplayPinnedByModel: () =>\n      tuc().getAppState().computerUseMcpState?.displayPinnedByModel ?? false,\n    getDisplayResolvedForApps: () =>\n      tuc().getAppState().computerUseMcpState?.displayResolvedForApps,\n    getLastScreenshotDims: (): ScreenshotDims | undefined => {\n      const d = tuc().getAppState().computerUseMcpState?.lastScreenshotDims\n      return d\n        ? {\n            ...d,\n            displayId: d.displayId ?? 0,\n            originX: d.originX ?? 0,\n            originY: d.originY ?? 0,\n          }\n        : undefined\n    },\n\n    // ── Write-backs ────────────────────────────────────────────────────────\n    // `setToolJSX` is guaranteed present — the gate in `main.tsx` excludes\n    // non-interactive sessions. The package's `_dialogSignal` (tool-finished\n    // dismissal) is irrelevant here: `setToolJSX` blocks the tool call, so\n    // the dialog can't outlive it. Ctrl+C is what matters, and\n    // `runPermissionDialog` wires that from the per-call ref's abortController.\n    onPermissionRequest: (req, _dialogSignal) => runPermissionDialog(req),\n\n    // Package does the merge (dedupe + truthy-only flags). We just persist.\n    onAllowedAppsChanged: (apps, flags) =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const prevApps = cu?.allowedApps\n        const prevFlags = cu?.grantFlags\n        const sameApps =\n          prevApps?.length === apps.length &&\n          apps.every((a, i) => prevApps[i]?.bundleId === a.bundleId)\n        const sameFlags =\n          prevFlags?.clipboardRead === flags.clipboardRead &&\n          prevFlags?.clipboardWrite === flags.clipboardWrite &&\n          prevFlags?.systemKeyCombos === flags.systemKeyCombos\n        return sameApps && sameFlags\n          ? prev\n          : {\n              ...prev,\n              computerUseMcpState: {\n                ...cu,\n                allowedApps: [...apps],\n                grantFlags: flags,\n              },\n            }\n      }),\n\n    onAppsHidden: ids => {\n      if (ids.length === 0) return\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const existing = cu?.hiddenDuringTurn\n        if (existing && ids.every(id => existing.has(id))) return prev\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            hiddenDuringTurn: new Set([...(existing ?? []), ...ids]),\n          },\n        }\n      })\n    },\n\n    // Resolver writeback only fires under a pin when Swift fell back to main\n    // (pinned display unplugged) — the pin is semantically dead, so clear it\n    // and the app-set key so the chase chain runs next time. When autoResolve\n    // was true, onDisplayResolvedForApps re-sets the key in the same tick.\n    onResolvedDisplayUpdated: id =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        if (\n          cu?.selectedDisplayId === id &&\n          !cu.displayPinnedByModel &&\n          cu.displayResolvedForApps === undefined\n        ) {\n          return prev\n        }\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            selectedDisplayId: id,\n            displayPinnedByModel: false,\n            displayResolvedForApps: undefined,\n          },\n        }\n      }),\n\n    // switch_display(name) pins; switch_display(\"auto\") unpins and clears the\n    // app-set key so the next screenshot auto-resolves fresh.\n    onDisplayPinned: id =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const pinned = id !== undefined\n        const nextResolvedFor = pinned ? cu?.displayResolvedForApps : undefined\n        if (\n          cu?.selectedDisplayId === id &&\n          cu?.displayPinnedByModel === pinned &&\n          cu?.displayResolvedForApps === nextResolvedFor\n        ) {\n          return prev\n        }\n        return {\n          ...prev,\n          computerUseMcpState: {\n            ...cu,\n            selectedDisplayId: id,\n            displayPinnedByModel: pinned,\n            displayResolvedForApps: nextResolvedFor,\n          },\n        }\n      }),\n\n    onDisplayResolvedForApps: key =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        if (cu?.displayResolvedForApps === key) return prev\n        return {\n          ...prev,\n          computerUseMcpState: { ...cu, displayResolvedForApps: key },\n        }\n      }),\n\n    onScreenshotCaptured: dims =>\n      tuc().setAppState(prev => {\n        const cu = prev.computerUseMcpState\n        const p = cu?.lastScreenshotDims\n        return p?.width === dims.width &&\n          p?.height === dims.height &&\n          p?.displayWidth === dims.displayWidth &&\n          p?.displayHeight === dims.displayHeight &&\n          p?.displayId === dims.displayId &&\n          p?.originX === dims.originX &&\n          p?.originY === dims.originY\n          ? prev\n          : {\n              ...prev,\n              computerUseMcpState: { ...cu, lastScreenshotDims: dims },\n            }\n      }),\n\n    // ── Lock — async, direct file-lock calls ───────────────────────────────\n    // No `lockHolderForGate` dance: the package's gate is async now. It\n    // awaits `checkCuLock`, and on `holder: undefined` + non-deferring tool\n    // awaits `acquireCuLock`. `defersLockAcquire` is the PACKAGE's set —\n    // the local copy is gone.\n    checkCuLock: async () => {\n      const c = await checkComputerUseLock()\n      switch (c.kind) {\n        case 'free':\n          return { holder: undefined, isSelf: false }\n        case 'held_by_self':\n          return { holder: getSessionId(), isSelf: true }\n        case 'blocked':\n          return { holder: c.by, isSelf: false }\n      }\n    },\n\n    // Called only when checkCuLock returned `holder: undefined`. The O_EXCL\n    // acquire is atomic — if another process grabbed it in the gap (rare),\n    // throw so the tool fails instead of proceeding without the lock.\n    // `fresh: false` (re-entrant) shouldn't happen given check said free,\n    // but is possible under parallel tool-use interleaving — don't spam the\n    // notification in that case.\n    acquireCuLock: async () => {\n      const r = await tryAcquireComputerUseLock()\n      if (r.kind === 'blocked') {\n        throw new Error(formatLockHeld(r.by))\n      }\n      if (r.fresh) {\n        // Global Escape → abort. Consumes the event (PI defense — prompt\n        // injection can't dismiss dialogs with Escape). The CGEventTap's\n        // CFRunLoopSource is processed by the drainRunLoop pump, so this\n        // holds a pump retain until unregisterEscHotkey() in cleanup.ts.\n        const escRegistered = registerEscHotkey(() => {\n          logForDebugging('[cu-esc] user escape, aborting turn')\n          tuc().abortController.abort()\n        })\n        tuc().sendOSNotification?.({\n          message: escRegistered\n            ? 'Claude is using your computer · press Esc to stop'\n            : 'Claude is using your computer · press Ctrl+C to stop',\n          notificationType: 'computer_use_enter',\n        })\n      }\n    },\n\n    formatLockHeldMessage: formatLockHeld,\n  }\n}\n\nfunction getOrBind(): Binding {\n  if (binding) return binding\n  const ctx = buildSessionContext()\n  binding = {\n    ctx,\n    dispatch: bindSessionContext(\n      getComputerUseHostAdapter(),\n      getChicagoCoordinateMode(),\n      ctx,\n    ),\n  }\n  return binding\n}\n\n/**\n * Returns the full override object for a single `mcp__computer-use__{toolName}`\n * tool: rendering overrides from `toolRendering.tsx` plus a `.call()` that\n * dispatches through the cached binder.\n */\ntype ComputerUseMCPToolOverrides = ReturnType<\n  typeof getComputerUseMCPRenderingOverrides\n> & {\n  call: CallOverride\n}\n\nexport function getComputerUseMCPToolOverrides(\n  toolName: string,\n): ComputerUseMCPToolOverrides {\n  const call: CallOverride = async (args, context: ToolUseContext) => {\n    currentToolUseContext = context\n    const { dispatch } = getOrBind()\n\n    const { telemetry, ...result } = await dispatch(toolName, args)\n\n    if (telemetry?.error_kind) {\n      logForDebugging(\n        `[Computer Use MCP] ${toolName} error_kind=${telemetry.error_kind}`,\n      )\n    }\n\n    // MCP content blocks → Anthropic API blocks. CU only produces text and\n    // pre-sized JPEG (executor.ts computeTargetDims → targetImageSize), so\n    // unlike the generic MCP path there's no resize needed — the MCP image\n    // shape just maps to the API's base64-source shape. The package's result\n    // type admits audio/resource too, but CU's handleToolCall never emits\n    // those; the fallthrough coerces them to empty text.\n    const data = Array.isArray(result.content)\n      ? result.content.map(item =>\n          item.type === 'image'\n            ? {\n                type: 'image' as const,\n                source: {\n                  type: 'base64' as const,\n                  media_type: item.mimeType ?? 'image/jpeg',\n                  data: item.data,\n                },\n              }\n            : {\n                type: 'text' as const,\n                text: item.type === 'text' ? item.text : '',\n              },\n        )\n      : result.content\n    return { data }\n  }\n\n  return {\n    ...getComputerUseMCPRenderingOverrides(toolName),\n    call,\n  }\n}\n\n/**\n * Render the approval dialog mid-call via `setToolJSX` + `Promise`, wait for\n * the user. Mirrors `spawnMultiAgent.ts:419-436` (the `It2SetupPrompt` pattern).\n *\n * The merge-into-AppState that used to live here (dedupe + truthy-only flags)\n * is now in the package's `bindSessionContext` → `onAllowedAppsChanged`.\n */\nasync function runPermissionDialog(\n  req: CuPermissionRequest,\n): Promise<CuPermissionResponse> {\n  const context = tuc()\n  const setToolJSX = context.setToolJSX\n  if (!setToolJSX) {\n    // Shouldn't happen — main.tsx gate excludes non-interactive. Fail safe.\n    return { granted: [], denied: [], flags: DEFAULT_GRANT_FLAGS }\n  }\n\n  try {\n    return await new Promise<CuPermissionResponse>((resolve, reject) => {\n      const signal = context.abortController.signal\n      // If already aborted, addEventListener won't fire — reject now so the\n      // promise doesn't hang waiting for a user who Ctrl+C'd.\n      if (signal.aborted) {\n        reject(new Error('Computer Use permission dialog aborted'))\n        return\n      }\n      const onAbort = (): void => {\n        signal.removeEventListener('abort', onAbort)\n        reject(new Error('Computer Use permission dialog aborted'))\n      }\n      signal.addEventListener('abort', onAbort)\n\n      setToolJSX({\n        jsx: React.createElement(ComputerUseApproval, {\n          request: req,\n          onDone: (resp: CuPermissionResponse) => {\n            signal.removeEventListener('abort', onAbort)\n            resolve(resp)\n          },\n        }),\n        shouldHidePromptInput: true,\n      })\n    })\n  } finally {\n    setToolJSX(null)\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SACEA,kBAAkB,EAClB,KAAKC,yBAAyB,EAC9B,KAAKC,gBAAgB,EACrB,KAAKC,mBAAmB,EACxB,KAAKC,oBAAoB,EACzBC,mBAAmB,EACnB,KAAKC,cAAc,QACd,uBAAuB;AAC9B,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,YAAY,QAAQ,0BAA0B;AACvD,SAASC,mBAAmB,QAAQ,yEAAyE;AAC7G,cAAcC,IAAI,EAAEC,cAAc,QAAQ,eAAe;AACzD,SAASC,eAAe,QAAQ,aAAa;AAC7C,SACEC,oBAAoB,EACpBC,yBAAyB,QACpB,sBAAsB;AAC7B,SAASC,iBAAiB,QAAQ,gBAAgB;AAClD,SAASC,wBAAwB,QAAQ,YAAY;AACrD,SAASC,yBAAyB,QAAQ,kBAAkB;AAC5D,SAASC,mCAAmC,QAAQ,oBAAoB;AAExE,KAAKC,YAAY,GAAGC,IAAI,CAACV,IAAI,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC;AAE9C,KAAKW,OAAO,GAAG;EACbC,GAAG,EAAErB,yBAAyB;EAC9BsB,QAAQ,EAAE,CAACC,IAAI,EAAE,MAAM,EAAEC,IAAI,EAAE,OAAO,EAAE,GAAGC,OAAO,CAACxB,gBAAgB,CAAC;AACtE,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAIyB,OAAO,EAAEN,OAAO,GAAG,SAAS;AAChC,IAAIO,qBAAqB,EAAEjB,cAAc,GAAG,SAAS;AAErD,SAASkB,GAAGA,CAAA,CAAE,EAAElB,cAAc,CAAC;EAC7B;EACA;EACA,OAAOiB,qBAAqB,CAAC;AAC/B;AAEA,SAASE,cAAcA,CAACC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;EAC9C,OAAO,qDAAqDA,MAAM,CAACC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,yDAAyD;AACzI;AAEA,OAAO,SAASC,mBAAmBA,CAAA,CAAE,EAAEhC,yBAAyB,CAAC;EAC/D,OAAO;IACL;IACAiC,cAAc,EAAEA,CAAA,KACdL,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEC,WAAW,IAAI,EAAE;IAC5DC,aAAa,EAAEA,CAAA,KACbT,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEG,UAAU,IACnDlC,mBAAmB;IACrB;IACAmC,sBAAsB,EAAEA,CAAA,KAAM,EAAE;IAChCC,oBAAoB,EAAEA,CAAA,KACpBZ,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEM,iBAAiB;IAC5DC,uBAAuB,EAAEA,CAAA,KACvBd,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEQ,oBAAoB,IAAI,KAAK;IACxEC,yBAAyB,EAAEA,CAAA,KACzBhB,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEU,sBAAsB;IACjEC,qBAAqB,EAAEA,CAAA,CAAE,EAAEzC,cAAc,GAAG,SAAS,IAAI;MACvD,MAAM0C,CAAC,GAAGnB,GAAG,CAAC,CAAC,CAACM,WAAW,CAAC,CAAC,CAACC,mBAAmB,EAAEa,kBAAkB;MACrE,OAAOD,CAAC,GACJ;QACE,GAAGA,CAAC;QACJE,SAAS,EAAEF,CAAC,CAACE,SAAS,IAAI,CAAC;QAC3BC,OAAO,EAAEH,CAAC,CAACG,OAAO,IAAI,CAAC;QACvBC,OAAO,EAAEJ,CAAC,CAACI,OAAO,IAAI;MACxB,CAAC,GACDC,SAAS;IACf,CAAC;IAED;IACA;IACA;IACA;IACA;IACA;IACAC,mBAAmB,EAAEA,CAACC,GAAG,EAAEC,aAAa,KAAKC,mBAAmB,CAACF,GAAG,CAAC;IAErE;IACAG,oBAAoB,EAAEA,CAACC,IAAI,EAAEC,KAAK,KAChC/B,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;MACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;MACnC,MAAM4B,QAAQ,GAAGD,EAAE,EAAE1B,WAAW;MAChC,MAAM4B,SAAS,GAAGF,EAAE,EAAExB,UAAU;MAChC,MAAM2B,QAAQ,GACZF,QAAQ,EAAEG,MAAM,KAAKR,IAAI,CAACQ,MAAM,IAChCR,IAAI,CAACS,KAAK,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAKN,QAAQ,CAACM,CAAC,CAAC,EAAEC,QAAQ,KAAKF,CAAC,CAACE,QAAQ,CAAC;MAC5D,MAAMC,SAAS,GACbP,SAAS,EAAEQ,aAAa,KAAKb,KAAK,CAACa,aAAa,IAChDR,SAAS,EAAES,cAAc,KAAKd,KAAK,CAACc,cAAc,IAClDT,SAAS,EAAEU,eAAe,KAAKf,KAAK,CAACe,eAAe;MACtD,OAAOT,QAAQ,IAAIM,SAAS,GACxBV,IAAI,GACJ;QACE,GAAGA,IAAI;QACP1B,mBAAmB,EAAE;UACnB,GAAG2B,EAAE;UACL1B,WAAW,EAAE,CAAC,GAAGsB,IAAI,CAAC;UACtBpB,UAAU,EAAEqB;QACd;MACF,CAAC;IACP,CAAC,CAAC;IAEJgB,YAAY,EAAEC,GAAG,IAAI;MACnB,IAAIA,GAAG,CAACV,MAAM,KAAK,CAAC,EAAE;MACtBtC,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;QACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;QACnC,MAAM0C,QAAQ,GAAGf,EAAE,EAAEgB,gBAAgB;QACrC,IAAID,QAAQ,IAAID,GAAG,CAACT,KAAK,CAACY,EAAE,IAAIF,QAAQ,CAACG,GAAG,CAACD,EAAE,CAAC,CAAC,EAAE,OAAOlB,IAAI;QAC9D,OAAO;UACL,GAAGA,IAAI;UACP1B,mBAAmB,EAAE;YACnB,GAAG2B,EAAE;YACLgB,gBAAgB,EAAE,IAAIG,GAAG,CAAC,CAAC,IAAIJ,QAAQ,IAAI,EAAE,CAAC,EAAE,GAAGD,GAAG,CAAC;UACzD;QACF,CAAC;MACH,CAAC,CAAC;IACJ,CAAC;IAED;IACA;IACA;IACA;IACAM,wBAAwB,EAAEH,EAAE,IAC1BnD,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;MACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;MACnC,IACE2B,EAAE,EAAErB,iBAAiB,KAAKsC,EAAE,IAC5B,CAACjB,EAAE,CAACnB,oBAAoB,IACxBmB,EAAE,CAACjB,sBAAsB,KAAKO,SAAS,EACvC;QACA,OAAOS,IAAI;MACb;MACA,OAAO;QACL,GAAGA,IAAI;QACP1B,mBAAmB,EAAE;UACnB,GAAG2B,EAAE;UACLrB,iBAAiB,EAAEsC,EAAE;UACrBpC,oBAAoB,EAAE,KAAK;UAC3BE,sBAAsB,EAAEO;QAC1B;MACF,CAAC;IACH,CAAC,CAAC;IAEJ;IACA;IACA+B,eAAe,EAAEJ,EAAE,IACjBnD,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;MACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;MACnC,MAAMiD,MAAM,GAAGL,EAAE,KAAK3B,SAAS;MAC/B,MAAMiC,eAAe,GAAGD,MAAM,GAAGtB,EAAE,EAAEjB,sBAAsB,GAAGO,SAAS;MACvE,IACEU,EAAE,EAAErB,iBAAiB,KAAKsC,EAAE,IAC5BjB,EAAE,EAAEnB,oBAAoB,KAAKyC,MAAM,IACnCtB,EAAE,EAAEjB,sBAAsB,KAAKwC,eAAe,EAC9C;QACA,OAAOxB,IAAI;MACb;MACA,OAAO;QACL,GAAGA,IAAI;QACP1B,mBAAmB,EAAE;UACnB,GAAG2B,EAAE;UACLrB,iBAAiB,EAAEsC,EAAE;UACrBpC,oBAAoB,EAAEyC,MAAM;UAC5BvC,sBAAsB,EAAEwC;QAC1B;MACF,CAAC;IACH,CAAC,CAAC;IAEJC,wBAAwB,EAAEC,GAAG,IAC3B3D,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;MACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;MACnC,IAAI2B,EAAE,EAAEjB,sBAAsB,KAAK0C,GAAG,EAAE,OAAO1B,IAAI;MACnD,OAAO;QACL,GAAGA,IAAI;QACP1B,mBAAmB,EAAE;UAAE,GAAG2B,EAAE;UAAEjB,sBAAsB,EAAE0C;QAAI;MAC5D,CAAC;IACH,CAAC,CAAC;IAEJC,oBAAoB,EAAEC,IAAI,IACxB7D,GAAG,CAAC,CAAC,CAACgC,WAAW,CAACC,IAAI,IAAI;MACxB,MAAMC,EAAE,GAAGD,IAAI,CAAC1B,mBAAmB;MACnC,MAAMuD,CAAC,GAAG5B,EAAE,EAAEd,kBAAkB;MAChC,OAAO0C,CAAC,EAAEC,KAAK,KAAKF,IAAI,CAACE,KAAK,IAC5BD,CAAC,EAAEE,MAAM,KAAKH,IAAI,CAACG,MAAM,IACzBF,CAAC,EAAEG,YAAY,KAAKJ,IAAI,CAACI,YAAY,IACrCH,CAAC,EAAEI,aAAa,KAAKL,IAAI,CAACK,aAAa,IACvCJ,CAAC,EAAEzC,SAAS,KAAKwC,IAAI,CAACxC,SAAS,IAC/ByC,CAAC,EAAExC,OAAO,KAAKuC,IAAI,CAACvC,OAAO,IAC3BwC,CAAC,EAAEvC,OAAO,KAAKsC,IAAI,CAACtC,OAAO,GACzBU,IAAI,GACJ;QACE,GAAGA,IAAI;QACP1B,mBAAmB,EAAE;UAAE,GAAG2B,EAAE;UAAEd,kBAAkB,EAAEyC;QAAK;MACzD,CAAC;IACP,CAAC,CAAC;IAEJ;IACA;IACA;IACA;IACA;IACAM,WAAW,EAAE,MAAAA,CAAA,KAAY;MACvB,MAAMC,CAAC,GAAG,MAAMpF,oBAAoB,CAAC,CAAC;MACtC,QAAQoF,CAAC,CAACC,IAAI;QACZ,KAAK,MAAM;UACT,OAAO;YAAEnE,MAAM,EAAEsB,SAAS;YAAE8C,MAAM,EAAE;UAAM,CAAC;QAC7C,KAAK,cAAc;UACjB,OAAO;YAAEpE,MAAM,EAAEvB,YAAY,CAAC,CAAC;YAAE2F,MAAM,EAAE;UAAK,CAAC;QACjD,KAAK,SAAS;UACZ,OAAO;YAAEpE,MAAM,EAAEkE,CAAC,CAACG,EAAE;YAAED,MAAM,EAAE;UAAM,CAAC;MAC1C;IACF,CAAC;IAED;IACA;IACA;IACA;IACA;IACA;IACAE,aAAa,EAAE,MAAAA,CAAA,KAAY;MACzB,MAAMC,CAAC,GAAG,MAAMxF,yBAAyB,CAAC,CAAC;MAC3C,IAAIwF,CAAC,CAACJ,IAAI,KAAK,SAAS,EAAE;QACxB,MAAM,IAAIK,KAAK,CAACzE,cAAc,CAACwE,CAAC,CAACF,EAAE,CAAC,CAAC;MACvC;MACA,IAAIE,CAAC,CAACE,KAAK,EAAE;QACX;QACA;QACA;QACA;QACA,MAAMC,aAAa,GAAG1F,iBAAiB,CAAC,MAAM;UAC5CH,eAAe,CAAC,qCAAqC,CAAC;UACtDiB,GAAG,CAAC,CAAC,CAAC6E,eAAe,CAACC,KAAK,CAAC,CAAC;QAC/B,CAAC,CAAC;QACF9E,GAAG,CAAC,CAAC,CAAC+E,kBAAkB,GAAG;UACzBC,OAAO,EAAEJ,aAAa,GAClB,mDAAmD,GACnD,sDAAsD;UAC1DK,gBAAgB,EAAE;QACpB,CAAC,CAAC;MACJ;IACF,CAAC;IAEDC,qBAAqB,EAAEjF;EACzB,CAAC;AACH;AAEA,SAASkF,SAASA,CAAA,CAAE,EAAE3F,OAAO,CAAC;EAC5B,IAAIM,OAAO,EAAE,OAAOA,OAAO;EAC3B,MAAML,GAAG,GAAGW,mBAAmB,CAAC,CAAC;EACjCN,OAAO,GAAG;IACRL,GAAG;IACHC,QAAQ,EAAEvB,kBAAkB,CAC1BiB,yBAAyB,CAAC,CAAC,EAC3BD,wBAAwB,CAAC,CAAC,EAC1BM,GACF;EACF,CAAC;EACD,OAAOK,OAAO;AAChB;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAKsF,2BAA2B,GAAGC,UAAU,CAC3C,OAAOhG,mCAAmC,CAC3C,GAAG;EACFiG,IAAI,EAAEhG,YAAY;AACpB,CAAC;AAED,OAAO,SAASiG,8BAA8BA,CAC5CC,QAAQ,EAAE,MAAM,CACjB,EAAEJ,2BAA2B,CAAC;EAC7B,MAAME,IAAI,EAAEhG,YAAY,GAAG,MAAAgG,CAAO1F,IAAI,EAAE6F,OAAO,EAAE3G,cAAc,KAAK;IAClEiB,qBAAqB,GAAG0F,OAAO;IAC/B,MAAM;MAAE/F;IAAS,CAAC,GAAGyF,SAAS,CAAC,CAAC;IAEhC,MAAM;MAAEO,SAAS;MAAE,GAAGC;IAAO,CAAC,GAAG,MAAMjG,QAAQ,CAAC8F,QAAQ,EAAE5F,IAAI,CAAC;IAE/D,IAAI8F,SAAS,EAAEE,UAAU,EAAE;MACzB7G,eAAe,CACb,sBAAsByG,QAAQ,eAAeE,SAAS,CAACE,UAAU,EACnE,CAAC;IACH;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMC,IAAI,GAAGC,KAAK,CAACC,OAAO,CAACJ,MAAM,CAACK,OAAO,CAAC,GACtCL,MAAM,CAACK,OAAO,CAACC,GAAG,CAACC,IAAI,IACrBA,IAAI,CAACC,IAAI,KAAK,OAAO,GACjB;MACEA,IAAI,EAAE,OAAO,IAAIC,KAAK;MACtBC,MAAM,EAAE;QACNF,IAAI,EAAE,QAAQ,IAAIC,KAAK;QACvBE,UAAU,EAAEJ,IAAI,CAACK,QAAQ,IAAI,YAAY;QACzCV,IAAI,EAAEK,IAAI,CAACL;MACb;IACF,CAAC,GACD;MACEM,IAAI,EAAE,MAAM,IAAIC,KAAK;MACrBI,IAAI,EAAEN,IAAI,CAACC,IAAI,KAAK,MAAM,GAAGD,IAAI,CAACM,IAAI,GAAG;IAC3C,CACN,CAAC,GACDb,MAAM,CAACK,OAAO;IAClB,OAAO;MAAEH;IAAK,CAAC;EACjB,CAAC;EAED,OAAO;IACL,GAAGxG,mCAAmC,CAACmG,QAAQ,CAAC;IAChDF;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe1D,mBAAmBA,CAChCF,GAAG,EAAEpD,mBAAmB,CACzB,EAAEuB,OAAO,CAACtB,oBAAoB,CAAC,CAAC;EAC/B,MAAMkH,OAAO,GAAGzF,GAAG,CAAC,CAAC;EACrB,MAAMyG,UAAU,GAAGhB,OAAO,CAACgB,UAAU;EACrC,IAAI,CAACA,UAAU,EAAE;IACf;IACA,OAAO;MAAEC,OAAO,EAAE,EAAE;MAAEC,MAAM,EAAE,EAAE;MAAE5E,KAAK,EAAEvD;IAAoB,CAAC;EAChE;EAEA,IAAI;IACF,OAAO,MAAM,IAAIqB,OAAO,CAACtB,oBAAoB,CAAC,CAAC,CAACqI,OAAO,EAAEC,MAAM,KAAK;MAClE,MAAMC,MAAM,GAAGrB,OAAO,CAACZ,eAAe,CAACiC,MAAM;MAC7C;MACA;MACA,IAAIA,MAAM,CAACC,OAAO,EAAE;QAClBF,MAAM,CAAC,IAAInC,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC3D;MACF;MACA,MAAMsC,OAAO,GAAGA,CAAA,CAAE,EAAE,IAAI,IAAI;QAC1BF,MAAM,CAACG,mBAAmB,CAAC,OAAO,EAAED,OAAO,CAAC;QAC5CH,MAAM,CAAC,IAAInC,KAAK,CAAC,wCAAwC,CAAC,CAAC;MAC7D,CAAC;MACDoC,MAAM,CAACI,gBAAgB,CAAC,OAAO,EAAEF,OAAO,CAAC;MAEzCP,UAAU,CAAC;QACTU,GAAG,EAAEzI,KAAK,CAAC0I,aAAa,CAACxI,mBAAmB,EAAE;UAC5CyI,OAAO,EAAE3F,GAAG;UACZ4F,MAAM,EAAEA,CAACC,IAAI,EAAEhJ,oBAAoB,KAAK;YACtCuI,MAAM,CAACG,mBAAmB,CAAC,OAAO,EAAED,OAAO,CAAC;YAC5CJ,OAAO,CAACW,IAAI,CAAC;UACf;QACF,CAAC,CAAC;QACFC,qBAAqB,EAAE;MACzB,CAAC,CAAC;IACJ,CAAC,CAAC;EACJ,CAAC,SAAS;IACRf,UAAU,CAAC,IAAI,CAAC;EAClB;AACF","ignoreList":[]}