@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.3

package/lib/types/host/services/playwright-sessions/index.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type PlaywrightSessionsConfig } from '../../../core/playwright-sessions/contracts.ts';
+export declare function register(ctx: Context, input?: PlaywrightSessionsConfig, ownerSignal?: AbortSignal): Promise<() => Promise<void>>;
+export { SessionBrowserManager } from './manager.ts';
+export { createSessionBrowser } from './child.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/host/services/playwright-sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/playwright-sessions/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAMlD,OAAO,EAAyI,KAAK,wBAAwB,EAA+B,MAAM,gDAAgD,CAAA;AA4BlQ,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,GAAE,wBAA6B,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAuG1I;AAED,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA"}

package/lib/types/host/services/playwright-sessions/index.js

@@ -0,0 +1,161 @@
+/** Per-session isolated Playwright MCP service domain. */
+import { createRequire } from 'node:module';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess';
+import { convertPlaywrightInputSchema } from "../../../core/playwright-sessions/schema.js";
+import { publicPlaywrightToolName } from "../../../core/playwright-sessions/names.js";
+import { PLAYWRIGHT_CLOSE_TOOL, playwrightSessionId, playwrightToolNeedsApproval, resolvePlaywrightSessionsConfig, UNSCOPED_PLAYWRIGHT_SESSION } from "../../../core/playwright-sessions/contracts.js";
+import { createSessionBrowser, extractText } from "./child.js";
+import { SessionBrowserManager } from "./manager.js";
+import { PlaywrightSessionsController } from "./controller.js";
+import { registerPlaywrightControlRoutes } from "./routes.js";
+import { registerLiveViewUpgrade } from "./live-view.js";
+import { abortable } from "../lifecycle.js";
+import { registerAsyncResources } from "../resources.js";
+import { pruneStaleProfiles, removeProfileDir } from "./profile-gc.js";
+function cliPath(require) {
+    const manifestPath = require.resolve('@playwright/mcp/package.json');
+    const manifest = require(manifestPath);
+    const relative = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.['playwright-mcp'] ?? 'cli.js';
+    return join(dirname(manifestPath), relative);
+}
+function sessionsRoot(configured) { return resolve(configured ?? join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'playwright-sessions')); }
+function browsersPath() { return join(homedir(), '.cache', 'ms-playwright'); }
+async function enumerate(require) {
+    const bundle = require(require.resolve('playwright-core/lib/coreBundle'));
+    if (!bundle.tools?.resolveCLIConfigForMCP || !bundle.tools.filteredTools)
+        throw new Error('playwright-core tools API is unavailable');
+    const config = await bundle.tools.resolveCLIConfigForMCP({ headless: true, allowedHosts: ['*'] });
+    return bundle.tools.filteredTools(config).flatMap(item => typeof item.schema?.name === 'string' ? [{ name: item.schema.name, title: typeof item.schema.title === 'string' ? item.schema.title : item.schema.name, description: typeof item.schema.description === 'string' ? item.schema.description : '', inputSchema: item.schema.inputSchema, type: typeof item.schema.type === 'string' ? item.schema.type : undefined }] : []);
+}
+function output(rawName) {
+    return { schema: { type: 'object', properties: { content: { type: 'array', items: {} } }, required: ['content'], additionalProperties: false }, render(_args, value) { return [{ type: 'text', text: extractText(value?.content, rawName) }]; } };
+}
+export async function register(ctx, input = {}, ownerSignal) {
+    const config = resolvePlaywrightSessionsConfig(input);
+    const require = createRequire(import.meta.url);
+    const root = sessionsRoot(config.sessionsRoot);
+    mkdirSync(root, { recursive: true });
+    let controller;
+    const manager = new SessionBrowserManager(sessionId => createSessionBrowser({
+        cliPath: cliPath(require),
+        sessionId,
+        sessionsRoot: root,
+        env: { ...scrubbedParentEnv(), PLAYWRIGHT_BROWSERS_PATH: process.env.PLAYWRIGHT_BROWSERS_PATH ?? browsersPath() },
+        mode: config.mode,
+        headless: config.headless,
+        browserChannel: config.browserChannel,
+        executablePath: config.executablePath,
+        allowedHosts: config.allowedHosts,
+        allowedOrigins: config.allowedOrigins,
+        blockedOrigins: config.blockedOrigins,
+        toolCallTimeoutMs: config.toolCallTimeoutMs,
+        liveView: config.liveView,
+    }), {
+        idleTimeoutMs: config.idleTimeoutMs,
+        maxConcurrentBrowsers: config.maxConcurrentBrowsers,
+        onDispose: sessionId => {
+            controller?.release(sessionId);
+            if (config.mode === 'launch' && config.pruneProfileOnDispose)
+                removeProfileDir(root, sessionId);
+        },
+    });
+    const sessionExists = async (sessionId) => {
+        try {
+            const sessions = ctx.sessionController;
+            await sessions.inspect(sessionId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    return registerAsyncResources(async (own) => {
+        own(() => manager.disposeAll());
+        controller = new PlaywrightSessionsController({ config, manager, sessionExists });
+        own(() => controller.dispose());
+        own(registerPlaywrightControlRoutes(ctx, controller));
+        // Agent-browser live view: a per-session WebSocket streaming CDP screencast
+        // of the browser the MCP child drives. Only mounted when liveView is on;
+        // the resolver reads the manager registry and never creates a browser.
+        if (config.liveView) {
+            own(registerLiveViewUpgrade(ctx, sessionId => manager.contextOf(sessionId)));
+        }
+        let tools = await abortable(enumerate(require), ownerSignal);
+        if (!config.unsafeTools)
+            tools = tools.filter(tool => tool.name !== 'browser_run_code_unsafe');
+        ownerSignal?.throwIfAborted();
+        if (tools.length === 0)
+            throw new Error('playwright-sessions: bundled tool list is empty');
+        try {
+            for (const tool of tools) {
+                ownerSignal?.throwIfAborted();
+                own(ctx.tools.register({
+                    name: publicPlaywrightToolName(tool.name),
+                    description: tool.description || tool.title,
+                    parameters: convertPlaywrightInputSchema(tool.inputSchema),
+                    output: output(tool.name),
+                    execute: async (args, exec) => {
+                        const id = playwrightSessionId(exec);
+                        if (config.mode === 'extension') {
+                            if (id === UNSCOPED_PLAYWRIGHT_SESSION)
+                                throw new Error('local Chrome requires a scoped DSH session');
+                            controller.requireOwner(id);
+                        }
+                        const browser = await manager.get(id);
+                        try {
+                            const result = await browser.call(tool.name, args ?? {}, exec.signal);
+                            return { content: result.content };
+                        }
+                        finally {
+                            if (tool.name === PLAYWRIGHT_CLOSE_TOOL)
+                                await manager.dispose(id);
+                        }
+                    },
+                }));
+            }
+        }
+        catch (error) {
+            throw new Error(`playwright-sessions tool registration failed; remove the global mcp-playwright row: ${String(error)}`, { cause: error });
+        }
+        const toolContracts = new Map(tools.map(tool => [publicPlaywrightToolName(tool.name), tool]));
+        const disposePolicy = config.mode === 'extension'
+            ? ctx.on('tools/pre-execute', async (exec, next) => {
+                const tool = toolContracts.get(exec.name);
+                if (tool === undefined)
+                    return next();
+                const id = playwrightSessionId(exec);
+                if (id === UNSCOPED_PLAYWRIGHT_SESSION)
+                    return { kind: 'deny', reason: 'local Chrome requires a scoped DSH session' };
+                try {
+                    controller.requireOwner(id);
+                }
+                catch (error) {
+                    return { kind: 'deny', reason: error instanceof Error ? error.message : String(error) };
+                }
+                if (playwrightToolNeedsApproval(tool.name, config.approvalPolicy)) {
+                    return { kind: 'ask', reason: `This action (${tool.title || tool.name}) will operate tabs in your logged-in Chrome.` };
+                }
+                return next();
+            })
+            : () => { };
+        own(disposePolicy);
+        own(ctx.on('workspace/session-stop', (...args) => {
+            const payload = args[0];
+            if (typeof payload?.sessionId === 'string')
+                void manager.dispose(payload.sessionId);
+        }));
+        const sweep = () => { if (config.mode === 'launch' && config.profileTtlMs > 0)
+            pruneStaleProfiles({ sessionsRoot: root, maxAgeMs: config.profileTtlMs, keepSessionIds: manager.ids() }); };
+        sweep();
+        const timer = config.profileTtlMs > 0 && config.profileSweepIntervalMs > 0 ? setInterval(sweep, config.profileSweepIntervalMs) : undefined;
+        timer?.unref();
+        if (timer)
+            own(() => { clearInterval(timer); });
+        ownerSignal?.throwIfAborted();
+    });
+}
+export { SessionBrowserManager } from "./manager.js";
+export { createSessionBrowser } from "./child.js";

package/lib/types/host/services/playwright-sessions/live-view.d.ts

@@ -0,0 +1,32 @@
+/** Agent-browser live view: serve one WebSocket client per session with CDP
+ *  screencast (JPEG frames out) and normalized mouse/keyboard input (CDP
+ *  `Input.*` commands in).
+ *
+ *  The session's Chromium runs as a persistent context launched by the host
+ *  (see child.ts `liveView` mode); `@playwright/mcp` connects to the same
+ *  browser over `--cdp-endpoint` and drives the persistent profile as the
+ *  browser's DEFAULT context, so the pages it creates show up in
+ *  `context.pages()`. We open a PAGE-scoped CDP session
+ *  (`context.newCDPSession(page)`) — never a browser-scoped session, where
+ *  the `Page.*`/`Input.*` domains are not routable — and poll
+ *  `context.pages()` for the page the MCP child is actually using, so a page
+ *  that appears after the first navigation, or that closes and is replaced,
+ *  is picked up without a reconnect.
+ */
+import type { BrowserContext } from 'playwright-core';
+import { WebSocket } from 'ws';
+import type { Context } from '@deepseek-ai/cordis';
+/** The live-view upgrade path (client wires to this by session id). */
+export declare const LIVE_VIEW_UPGRADE_PATH = "/playwright-sessions/ws/browser";
+/** Resolve a session's browser context (async; resolver must not create a
+ *  browser — a live-view client opening the socket is not a tool call). */
+export type LiveContextResolver = (sessionId: string) => Promise<BrowserContext | null | undefined>;
+/**
+ * Serve a live view for `context` over `ws`. Resolves once the first poll is
+ * scheduled; the connection lives until the client closes (or errors), at
+ * which point the poll timer and the page CDP session are torn down.
+ */
+export declare function serveScreencast(context: BrowserContext, ws: WebSocket): Promise<void>;
+/** Register the `/playwright-sessions/ws/browser` live-view upgrade. */
+export declare function registerLiveViewUpgrade(ctx: Context, resolveContext: LiveContextResolver): () => void;
+//# sourceMappingURL=live-view.d.ts.map

package/lib/types/host/services/playwright-sessions/live-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-view.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/playwright-sessions/live-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,cAAc,EAAQ,MAAM,iBAAiB,CAAA;AAG3D,OAAO,EAAE,SAAS,EAAmB,MAAM,IAAI,CAAA;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,oCAAoC,CAAA;AASvE;2EAC2E;AAC3E,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;AAEnG;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAwI3F;AAED,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAuCrG"}

package/lib/types/host/services/playwright-sessions/live-view.js

@@ -0,0 +1,188 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import { buildFrameMessage, buildStatusMessage, mapInputMessage, } from "../../../core/playwright-sessions/wire.js";
+import { accessTrustOf } from "../access-trust/index.js";
+const POLL_INTERVAL_MS = 500;
+/** The live-view upgrade path (client wires to this by session id). */
+export const LIVE_VIEW_UPGRADE_PATH = '/playwright-sessions/ws/browser';
+/**
+ * Serve a live view for `context` over `ws`. Resolves once the first poll is
+ * scheduled; the connection lives until the client closes (or errors), at
+ * which point the poll timer and the page CDP session are torn down.
+ */
+export async function serveScreencast(context, ws) {
+    let attachedPage;
+    let pageCdp;
+    let noPageSent = false;
+    let settled = false;
+    const safeSend = (data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            try {
+                ws.send(data);
+            }
+            catch {
+                // Client may have torn the socket down between the readyState read and send.
+            }
+        }
+    };
+    const sendStatus = (state, message) => {
+        safeSend(buildStatusMessage(state, message));
+    };
+    const detach = async () => {
+        const cdp = pageCdp;
+        pageCdp = undefined;
+        if (cdp !== undefined) {
+            try {
+                await cdp.send('Page.stopScreencast');
+            }
+            catch {
+                // Page may already be gone; nothing left to stop.
+            }
+            try {
+                await cdp.detach();
+            }
+            catch {
+                // Session may already be detached.
+            }
+        }
+    };
+    const attach = async (page) => {
+        attachedPage = page; // synchronous intent; guards re-entry and supersedes older attaches
+        await detach();
+        try {
+            const cdp = (await context.newCDPSession(page));
+            if (attachedPage !== page || settled) {
+                try {
+                    await cdp.detach();
+                }
+                catch {
+                    // Superseded before it was used.
+                }
+                return;
+            }
+            cdp.on('Page.screencastFrame', (params) => {
+                const frame = params;
+                safeSend(buildFrameMessage(frame));
+                // Ack is fire-and-forget; a failed ack only pauses future frames.
+                cdp.send('Page.screencastFrameAck', { sessionId: frame.sessionId }).catch(() => { });
+            });
+            await cdp.send('Page.startScreencast', { format: 'jpeg', quality: 80, everyNthFrame: 1 });
+            pageCdp = cdp;
+            noPageSent = false;
+        }
+        catch (error) {
+            pageCdp = undefined;
+            if (attachedPage === page && !settled) {
+                sendStatus('error', `playwright-sessions: failed to start screencast: ${String(error)}`);
+            }
+        }
+    };
+    const findPage = () => {
+        const pages = context.pages().filter((page) => !page.isClosed());
+        return pages.find((page) => page.url() !== '' && page.url() !== 'about:blank') ?? pages.at(-1);
+    };
+    const poll = () => {
+        if (settled)
+            return;
+        const page = findPage();
+        if (page === undefined) {
+            if (attachedPage !== undefined) {
+                attachedPage = undefined;
+                void detach();
+            }
+            if (!noPageSent) {
+                noPageSent = true;
+                sendStatus('no-page');
+            }
+            return;
+        }
+        if (attachedPage !== page) {
+            void attach(page);
+        }
+    };
+    const onMessage = (data) => {
+        let raw;
+        try {
+            raw = JSON.parse(String(data));
+        }
+        catch {
+            return;
+        }
+        const command = mapInputMessage(raw);
+        if (command === null)
+            return;
+        const cdp = pageCdp;
+        if (cdp === undefined) {
+            sendStatus('no-page');
+            return;
+        }
+        cdp.send(command.method, command.params).catch((error) => {
+            sendStatus('error', `playwright-sessions: input failed: ${String(error)}`);
+        });
+    };
+    let pollTimer;
+    const cleanup = () => {
+        if (settled)
+            return;
+        settled = true;
+        if (pollTimer !== undefined)
+            clearInterval(pollTimer);
+        ws.off('message', onMessage);
+        attachedPage = undefined;
+        void detach();
+    };
+    ws.on('message', onMessage);
+    ws.on('close', cleanup);
+    ws.on('error', cleanup);
+    // The browser (persistent context) closed while a view was attached: the
+    // live session is over — tell the client and tear the view down.
+    context.on('close', () => {
+        if (!settled) {
+            sendStatus('browser-closed');
+            cleanup();
+        }
+    });
+    pollTimer = setInterval(poll, POLL_INTERVAL_MS);
+    pollTimer.unref?.();
+    poll();
+}
+/** Register the `/playwright-sessions/ws/browser` live-view upgrade. */
+export function registerLiveViewUpgrade(ctx, resolveContext) {
+    const wss = new WebSocketServer({ noServer: true });
+    const isTrusted = accessTrustOf(ctx).isTrusted;
+    const dispose = ctx.webServer.registerUpgrade({
+        path: LIVE_VIEW_UPGRADE_PATH,
+        handler: (req, socket, head) => {
+            if (!isTrusted(req)) {
+                socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const sessionId = url.searchParams.get('sessionId');
+            if (sessionId === null || sessionId === '') {
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            // Resolve asynchronously (never create a browser just for a view), then
+            // complete the upgrade with the resolved context or a clean refusal.
+            void resolveContext(sessionId).then(context => {
+                if (context === null || context === undefined) {
+                    socket.write('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
+                    socket.destroy();
+                    return;
+                }
+                wss.handleUpgrade(req, socket, head, (ws) => {
+                    void serveScreencast(context, ws);
+                });
+            }, () => {
+                socket.write('HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+            });
+        },
+    });
+    return () => {
+        dispose();
+        wss.close();
+    };
+}

package/lib/types/host/services/playwright-sessions/manager.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Per-session browser registry.
+ *
+ * Lazily creates one {@link SessionBrowser} per conversation and keeps the
+ * mapping stable while the session stays active: a session's first playwright
+ * tool call spawns its browser, every later call reuses it, and no other
+ * session can ever see it. Failure to create a handle removes the entry so the
+ * next call retries instead of wedging the session.
+ *
+ * Lifecycle guards (both optional via config):
+ * - idle TTL — unused browsers are disposed after `idleTimeoutMs`
+ * - concurrency cap — creating a new browser may dispose the least-recently
+ *   used idle browser so at most `maxConcurrentBrowsers` stay alive
+ */
+import type { SessionBrowser } from './child.ts';
+export type SessionBrowserFactory = (sessionId: string) => Promise<SessionBrowser>;
+export interface SessionBrowserManagerOptions {
+    /**
+     * Dispose a browser after this many milliseconds with no get/call.
+     * `0` disables idle eviction. Default is set by the plugin apply site.
+     */
+    idleTimeoutMs: number;
+    /**
+     * Soft cap on live browsers. Creating one more may dispose the LRU idle
+     * entry. `0` disables the cap.
+     */
+    maxConcurrentBrowsers: number;
+    /** Optional clock for tests. */
+    now?: () => number;
+    /** Optional timer hooks for tests. */
+    setTimeout?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimeout?: (handle: ReturnType<typeof setTimeout>) => void;
+    /**
+     * Called after a session browser process is disposed (idle TTL, concurrency
+     * eviction, browser_close, or disposeAll). Used for disk profile GC.
+     */
+    onDispose?: (sessionId: string) => void | Promise<void>;
+}
+export declare class SessionBrowserManager {
+    private readonly factory;
+    private readonly options;
+    private readonly sessions;
+    private readonly now;
+    private readonly setTimeoutFn;
+    private readonly clearTimeoutFn;
+    constructor(factory: SessionBrowserFactory, options: SessionBrowserManagerOptions);
+    /** Resolve the browser for one session, creating it on first use. */
+    get(sessionId: string): Promise<SessionBrowser>;
+    /** Number of sessions that have (or are creating) a browser. */
+    get size(): number;
+    /** Every session id currently tracked. */
+    ids(): string[];
+    /** Whether a session currently owns (or is creating) a browser connection. */
+    has(sessionId: string): boolean;
+    /**
+     * The host-owned persistent context of a session browser, when one exists
+     * AND was created in liveView mode (dual-owner). Never creates a browser:
+     * the live-view upgrade must not spawn a browser just because a client
+     * opened the view.
+     */
+    contextOf(sessionId: string): Promise<SessionBrowser['context']>;
+    /** Dispose one session browser and drop it from the registry. */
+    dispose(sessionId: string): Promise<void>;
+    /** Close and dispose every session browser; the registry empties. */
+    disposeAll(): Promise<void>;
+    /**
+     * Wrap call so each use refreshes the idle timer and marks the entry busy
+     * (idle eviction will not steal a browser mid-call).
+     */
+    private wrap;
+    private beginUse;
+    private endUse;
+    private touch;
+    private armIdleTimer;
+    private clearIdleTimer;
+    /** Idle timer fired: dispose only if still idle and not busy. */
+    private disposeIdle;
+    /**
+     * Before creating `incomingId`, dispose LRU idle browsers until under the
+     * concurrency cap. Busy browsers are skipped; if every other browser is
+     * busy and the cap is still reached, the absolute LRU (including busy) is
+     * force-disposed so a new session can start.
+     */
+    private ensureCapacity;
+    private pickEvictionVictim;
+}
+//# sourceMappingURL=manager.d.ts.map

package/lib/types/host/services/playwright-sessions/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/playwright-sessions/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,MAAM,MAAM,qBAAqB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;AAElF,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAA;IAC7B,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,sCAAsC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IAC1E,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,IAAI,CAAA;IAC9D;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACxD;AAUD,qBAAa,qBAAqB;IAO9B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA+D;IAC5F,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;gBAG7D,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,4BAA4B;IAOxD,qEAAqE;IAC/D,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAiBrD,gEAAgE;IAChE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,0CAA0C;IAC1C,GAAG,IAAI,MAAM,EAAE;IAIf,8EAA8E;IAC9E,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B;;;;;OAKG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IAMhE,iEAAiE;IAC3D,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB/C,qEAAqE;IAC/D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC;;;OAGG;IACH,OAAO,CAAC,IAAI;IAkBZ,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,MAAM;IAOd,OAAO,CAAC,KAAK;IAOb,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,cAAc;IAMtB,iEAAiE;YACnD,WAAW;IAezB;;;;;OAKG;YACW,cAAc;IAW5B,OAAO,CAAC,kBAAkB;CAa3B"}