@kkvcrobatz107/codegraph 0.9.6-pkm.1

package/dist/mcp/index.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * CodeGraph MCP Server
+ *
+ * Model Context Protocol server that exposes CodeGraph functionality
+ * as tools for AI assistants like Claude.
+ *
+ * @module mcp
+ *
+ * @example
+ * ```typescript
+ * import { MCPServer } from 'codegraph';
+ *
+ * const server = new MCPServer('/path/to/project');
+ * await server.start();
+ * ```
+ *
+ * Runtime modes (decided in {@link MCPServer.start}):
+ *
+ * - **Direct** — one process serves one MCP client over stdio. The pre-#411
+ *   behavior; used when the user opts out (`CODEGRAPH_NO_DAEMON=1`), no
+ *   `.codegraph/` is reachable, or the daemon machinery fails for any reason.
+ * - **Proxy** — what an MCP host actually talks to when sharing is on: a thin
+ *   stdio↔socket pipe to the shared daemon. The proxy carries the #277 PPID
+ *   watchdog, so a SIGKILL'd host reaps its proxy promptly. See {@link ./proxy.ts}.
+ * - **Daemon** — a *detached* background process (its own session/process
+ *   group) that serves N proxies over a Unix-domain socket / named pipe,
+ *   sharing one CodeGraph + watcher + SQLite handle. Spawned on demand; never a
+ *   child of any host, so it survives individual sessions and is reaped by
+ *   client-refcount + idle timeout. See {@link ./daemon.ts} and issue #411.
+ *
+ * The detached-daemon + always-proxy split is the fix for the review finding
+ * that the original in-process daemon (a) was the first host's child, so closing
+ * that terminal severed every other client, and (b) disabled the PPID watchdog,
+ * regressing #277 (orphaned daemons on host SIGKILL).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGraphPackageVersion = exports.Daemon = exports.ToolHandler = exports.tools = exports.StdioTransport = exports.MCPServer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const index_1 = require("../index");
+const directory_1 = require("../directory");
+const transport_1 = require("./transport");
+const engine_1 = require("./engine");
+const session_1 = require("./session");
+const daemon_1 = require("./daemon");
+const proxy_1 = require("./proxy");
+const daemon_paths_1 = require("./daemon-paths");
+const wasm_runtime_flags_1 = require("../extraction/wasm-runtime-flags");
+/**
+ * How often to poll `process.ppid` to detect parent process death (see #277).
+ * 5s is a deliberate trade-off: the failure mode being guarded against is rare
+ * (parent SIGKILL'd), and longer poll = less wakeup overhead while idle.
+ */
+const DEFAULT_PPID_POLL_MS = 5000;
+/**
+ * Env var that marks a process as the *detached daemon* itself (set by
+ * {@link spawnDetachedDaemon} when it re-invokes the CLI). Without it a
+ * `serve --mcp` invocation is a launcher that connects-or-spawns; with it, the
+ * process IS the daemon and must never try to spawn another (infinite spawn).
+ */
+const DAEMON_INTERNAL_ENV = 'CODEGRAPH_DAEMON_INTERNAL';
+/**
+ * Retries for the detached daemon arbitrating the O_EXCL lock against a racing
+ * sibling. Tiny — the lock resolves on the first round in practice; the retries
+ * only cover clearing a genuinely stale (dead-pid) lockfile.
+ */
+const TAKEOVER_MAX_RETRIES = 5;
+const TAKEOVER_RETRY_DELAY_MS = 100;
+/**
+ * How long a launcher waits for a freshly-spawned daemon to bind its socket
+ * before giving up and running in-process. The daemon binds the socket *before*
+ * the (backgrounded) engine/grammar warm-up, so this only needs to cover node
+ * process startup. 60 × 100ms = 6s of headroom for a cold/slow box; on the
+ * common path the socket appears within a few rounds.
+ */
+const DAEMON_CONNECT_MAX_RETRIES = 60;
+const DAEMON_CONNECT_RETRY_DELAY_MS = 100;
+/**
+ * Resolve the PPID watchdog poll interval from an env override. A value of
+ * `0` disables the watchdog entirely (escape hatch for embedded scenarios
+ * where the parent legitimately re-parents the server on purpose). Anything
+ * non-numeric or negative falls back to the default.
+ */
+function parsePpidPollMs(raw) {
+    if (raw === undefined || raw === '')
+        return DEFAULT_PPID_POLL_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return DEFAULT_PPID_POLL_MS;
+    if (parsed < 0)
+        return DEFAULT_PPID_POLL_MS;
+    return Math.floor(parsed);
+}
+/**
+ * Parse the host PID propagated across the `--liftoff-only` re-exec
+ * ({@link HOST_PPID_ENV}). Returns a positive integer PID, or null when
+ * unset/invalid — the direct-launch path, where the watchdog falls back to
+ * `process.ppid` divergence. PIDs of 0/1 are rejected (0 = unknown, 1 = init,
+ * i.e. already orphaned), so the watchdog doesn't latch onto init.
+ */
+function parseHostPpid(raw) {
+    if (raw === undefined || raw === '')
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed <= 1)
+        return null;
+    return parsed;
+}
+/** Whether `CODEGRAPH_NO_DAEMON` was set to a truthy value. */
+function daemonOptOutSet() {
+    const raw = process.env.CODEGRAPH_NO_DAEMON;
+    if (!raw)
+        return false;
+    return raw !== '0' && raw.toLowerCase() !== 'false';
+}
+/** Whether this process was spawned to BE the detached daemon. */
+function daemonInternalSet() {
+    const raw = process.env[DAEMON_INTERNAL_ENV];
+    return !!raw && raw !== '0' && raw.toLowerCase() !== 'false';
+}
+/**
+ * Resolve the project root the daemon machinery should key on. Returns
+ * `null` when no `.codegraph/` is reachable from the candidate path — in
+ * that case the caller must run in direct mode, since the daemon lockfile
+ * and socket both live under `.codegraph/`.
+ *
+ * The result is canonicalized with `realpathSync` so every client converges on
+ * the same socket/lock path regardless of how it expressed the path: a client
+ * launched with cwd under a symlink (e.g. macOS `/var` → `/private/var`, where
+ * spawned `process.cwd()` is already realpath'd) and one that passed a
+ * symlinked `rootUri` would otherwise hash to different sockets and silently
+ * fail to share the daemon.
+ */
+function resolveDaemonRoot(explicitPath) {
+    const candidate = explicitPath ?? process.cwd();
+    const root = (0, index_1.findNearestCodeGraphRoot)(candidate);
+    if (!root)
+        return null;
+    try {
+        return fs.realpathSync(root);
+    }
+    catch {
+        return root;
+    }
+}
+/**
+ * Spawn the shared daemon as a fully detached background process: its own
+ * session/process group (so a SIGHUP/SIGINT to the launcher's terminal can't
+ * reach it) with stdio decoupled from the launcher (logs to
+ * `.codegraph/daemon.log`). Re-invokes the *same* CLI faithfully across dev and
+ * bundled launches by reusing `process.argv[0]` (the right node), the current
+ * `process.execArgv` (carries `--liftoff-only`, so the daemon never re-execs)
+ * and `process.argv[1]` (this script). The spawned process self-arbitrates the
+ * O_EXCL lock, so racing launchers may each spawn one — losers exit and every
+ * launcher proxies through the single winner.
+ */
+function spawnDetachedDaemon(root) {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        // No resolvable CLI entry point to re-invoke — let the caller fall back to
+        // direct mode rather than spawn something broken.
+        throw new Error('cannot resolve CLI script path to spawn the daemon');
+    }
+    let logFd = null;
+    let stdio = 'ignore';
+    try {
+        logFd = fs.openSync(path.join((0, directory_1.getCodeGraphDir)(root), 'daemon.log'), 'a');
+        stdio = ['ignore', logFd, logFd];
+    }
+    catch {
+        stdio = 'ignore'; // no log file — discard daemon output rather than fail
+    }
+    try {
+        const child = (0, child_process_1.spawn)(process.execPath, [...process.execArgv, scriptPath, 'serve', '--mcp', '--path', root], {
+            detached: true,
+            stdio,
+            windowsHide: true,
+            env: { ...process.env, [DAEMON_INTERNAL_ENV]: '1' },
+        });
+        child.unref();
+    }
+    finally {
+        // The child holds its own dup of the log fd now; the launcher doesn't need it.
+        if (logFd !== null) {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch { /* ignore */ }
+        }
+    }
+}
+/**
+ * MCP Server for CodeGraph
+ *
+ * Implements the Model Context Protocol to expose CodeGraph
+ * functionality as tools that can be called by AI assistants.
+ *
+ * Backwards-compatible constructor and `start()` signature with the
+ * pre-issue-#411 implementation: callers continue to do
+ * `new MCPServer(path).start()`. Internally we now pick from direct / proxy /
+ * daemon at start time.
+ */
+class MCPServer {
+    projectPath;
+    // Direct-mode-only state. In daemon mode the per-connection sessions live
+    // inside the Daemon class; in proxy mode there is no session at all.
+    session = null;
+    engine = null;
+    daemon = null;
+    ppidWatchdog = null;
+    // PPID watchdog baseline — captured at construction so we always have a
+    // baseline, even if start() runs after a fork-style reparent.
+    originalPpid = process.ppid;
+    hostPpid = parseHostPpid(process.env[wasm_runtime_flags_1.HOST_PPID_ENV]);
+    // Idempotency guard for stop().
+    stopped = false;
+    mode = 'unstarted';
+    constructor(projectPath) {
+        this.projectPath = projectPath || null;
+    }
+    /**
+     * Start the MCP server.
+     *
+     * Decision order:
+     *   1. `CODEGRAPH_NO_DAEMON=1` → direct mode (unchanged pre-#411 behavior).
+     *   2. `CODEGRAPH_DAEMON_INTERNAL=1` → we ARE the detached daemon; listen.
+     *   3. No `.codegraph/` reachable → direct mode (the daemon's lockfile and
+     *      socket both live under `.codegraph/`).
+     *   4. Otherwise connect to (or spawn) the shared daemon and proxy to it.
+     *
+     * On any unexpected failure in step 4 we transparently fall back to direct
+     * mode — a misbehaving daemon must never block a session from starting.
+     */
+    async start() {
+        // The detached daemon process itself. Checked before the opt-out so the
+        // daemon honors the same env it was spawned with (it never sets NO_DAEMON).
+        if (daemonInternalSet()) {
+            return this.startDaemonProcess();
+        }
+        // Direct mode if the user opted out. Setting the env var is sufficient to
+        // get the pre-#411 single-process behavior.
+        if (daemonOptOutSet()) {
+            return this.startDirect('CODEGRAPH_NO_DAEMON set');
+        }
+        const root = resolveDaemonRoot(this.projectPath);
+        if (!root) {
+            // No initialized project found — daemon mode has nowhere to put its
+            // socket. The fresh-checkout / outside-project case; behave as before.
+            return this.startDirect('no .codegraph/ root found');
+        }
+        try {
+            const mode = await this.connectOrSpawnDaemon(root);
+            if (mode === 'fallback') {
+                return this.startDirect('daemon unavailable; fallback to direct');
+            }
+            // 'proxy': connectOrSpawnDaemon ran the stdio↔socket pipe to completion
+            // (it only returns once the host disconnected). The process is now
+            // expected to terminate naturally — the proxy installed its own watchdog.
+            this.mode = 'proxy';
+            return;
+        }
+        catch (err) {
+            // Belt-and-braces: if anything throws inside the daemon machinery,
+            // never wedge the user — fall back to a working direct-mode session.
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[CodeGraph MCP] Daemon path failed (${msg}); falling back to direct mode.\n`);
+            return this.startDirect('daemon path threw');
+        }
+    }
+    /**
+     * Stop the server. In daemon mode this triggers graceful shutdown of every
+     * connected session; in direct mode it mirrors the pre-#411 behavior (close
+     * cg, exit). Proxy mode never routes through here — the proxy exits itself.
+     */
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.ppidWatchdog) {
+            clearInterval(this.ppidWatchdog);
+            this.ppidWatchdog = null;
+        }
+        if (this.daemon) {
+            void this.daemon.stop('stop()');
+            // Daemon.stop calls process.exit; nothing else to do.
+            return;
+        }
+        if (this.session) {
+            this.session.stop();
+            this.session = null;
+        }
+        if (this.engine) {
+            this.engine.stop();
+            this.engine = null;
+        }
+        process.exit(0);
+    }
+    /** Single-process stdio MCP session — the pre-issue-#411 code path. */
+    async startDirect(reason) {
+        if (reason && process.env.CODEGRAPH_MCP_DEBUG) {
+            process.stderr.write(`[CodeGraph MCP] Direct mode: ${reason}.\n`);
+        }
+        this.engine = new engine_1.MCPEngine();
+        const transport = new transport_1.StdioTransport();
+        this.session = new session_1.MCPSession(transport, this.engine, {
+            explicitProjectPath: this.projectPath,
+        });
+        if (this.projectPath) {
+            // Background init so the initialize response stays fast (#172).
+            void this.engine.ensureInitialized(this.projectPath);
+        }
+        this.session.start();
+        // Detect parent-process death — same logic as pre-refactor. When stdin
+        // closes we go through StdioTransport's `process.exit(0)` already, but
+        // SIGKILL of the parent doesn't reliably close stdin on Linux (#277).
+        process.stdin.on('end', () => this.stop());
+        process.stdin.on('close', () => this.stop());
+        this.mode = 'direct';
+        this.installSignalHandlers();
+        this.installPpidWatchdog();
+    }
+    /**
+     * Run as the detached shared daemon (process spawned with
+     * `CODEGRAPH_DAEMON_INTERNAL=1`). Arbitrate the O_EXCL lock, then either
+     * become the daemon (bind the socket, serve forever) or — if a live daemon
+     * already holds the lock — exit so we don't leak a redundant process.
+     *
+     * No PPID watchdog and no stdin handlers: the daemon is detached on purpose
+     * and reaps itself via client-refcount + idle timeout (see {@link Daemon}).
+     */
+    async startDaemonProcess() {
+        const root = resolveDaemonRoot(this.projectPath) ?? this.projectPath ?? process.cwd();
+        for (let attempt = 0; attempt < TAKEOVER_MAX_RETRIES; attempt++) {
+            const lock = (0, daemon_1.tryAcquireDaemonLock)(root);
+            if (lock.kind === 'acquired') {
+                const daemon = new daemon_1.Daemon(root);
+                await daemon.start();
+                this.daemon = daemon;
+                this.mode = 'daemon';
+                return; // the net.Server keeps the process alive
+            }
+            // Taken. If the holder is alive, another daemon already serves (or is
+            // binding) — we're redundant; exit cleanly so the launcher proxies to it.
+            const existing = lock.existing;
+            if (existing && existing.pid > 0 && (0, daemon_1.isProcessAlive)(existing.pid)) {
+                process.stderr.write(`[CodeGraph daemon] Another daemon (pid ${existing.pid}) already holds the lock; exiting.\n`);
+                process.exit(0);
+            }
+            // Holder is dead (or the record is unreadable) — clear it (pid-verified,
+            // so we never delete a live daemon's lock) and retry the acquire.
+            (0, daemon_1.clearStaleDaemonLock)(lock.pidPath, existing?.pid);
+            await sleep(TAKEOVER_RETRY_DELAY_MS);
+        }
+        process.stderr.write('[CodeGraph daemon] Could not acquire the daemon lock; exiting.\n');
+        process.exit(0);
+    }
+    /**
+     * Become a proxy to the shared daemon, spawning the daemon first if none is
+     * reachable. Returns 'proxy' once the proxied session has run to completion
+     * (the host disconnected), or 'fallback' if the caller should run in-process.
+     */
+    async connectOrSpawnDaemon(root) {
+        const socketPath = (0, daemon_paths_1.getDaemonSocketPath)(root);
+        // Fast path: a daemon may already be listening. On success runProxy pipes
+        // stdio until the host disconnects, so a 'proxied' outcome means this
+        // process has finished its entire job.
+        let probe = await (0, proxy_1.runProxy)(socketPath);
+        if (probe.outcome === 'proxied')
+            return 'proxy';
+        if (probe.reason === 'version mismatch')
+            return 'fallback';
+        // No reachable daemon — spawn one (detached) and wait for it to bind.
+        spawnDetachedDaemon(root);
+        for (let attempt = 0; attempt < DAEMON_CONNECT_MAX_RETRIES; attempt++) {
+            await sleep(DAEMON_CONNECT_RETRY_DELAY_MS);
+            probe = await (0, proxy_1.runProxy)(socketPath);
+            if (probe.outcome === 'proxied')
+                return 'proxy';
+            if (probe.reason === 'version mismatch')
+                return 'fallback';
+        }
+        // Daemon never came up in time — run in-process so the user is never blocked.
+        return 'fallback';
+    }
+    /** Standard SIGINT/SIGTERM handlers that route to our `stop()` (direct mode). */
+    installSignalHandlers() {
+        process.on('SIGINT', () => this.stop());
+        process.on('SIGTERM', () => this.stop());
+    }
+    /**
+     * PPID watchdog (#277) — direct mode only. Daemon mode is detached on purpose
+     * and reaps via idle timeout; proxy mode installs its own watchdog inside
+     * {@link runProxy}. So this only ever runs for an in-process direct session.
+     */
+    installPpidWatchdog() {
+        if (this.mode !== 'direct')
+            return;
+        const pollMs = parsePpidPollMs(process.env.CODEGRAPH_PPID_POLL_MS);
+        if (pollMs <= 0)
+            return;
+        this.ppidWatchdog = setInterval(() => {
+            const current = process.ppid;
+            const ppidChanged = current !== this.originalPpid;
+            const hostGone = this.hostPpid !== null && !(0, daemon_1.isProcessAlive)(this.hostPpid);
+            if (ppidChanged || hostGone) {
+                const reason = ppidChanged
+                    ? `ppid ${this.originalPpid} -> ${current}`
+                    : `host pid ${this.hostPpid} exited`;
+                process.stderr.write(`[CodeGraph MCP] Parent process exited (${reason}); shutting down.\n`);
+                this.stop();
+            }
+        }, pollMs);
+        this.ppidWatchdog.unref();
+    }
+}
+exports.MCPServer = MCPServer;
+function sleep(ms) {
+    // Deliberately NOT unref'd. During the daemon connect/takeover retry loop we
+    // may be between processes — no socket bound yet, no transport, no listener
+    // pinning the event loop. An unref'd timer would let Node drain the loop and
+    // exit silently before we get a chance to try again.
+    return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+// Export for use in CLI
+var transport_2 = require("./transport");
+Object.defineProperty(exports, "StdioTransport", { enumerable: true, get: function () { return transport_2.StdioTransport; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_1.tools; } });
+Object.defineProperty(exports, "ToolHandler", { enumerable: true, get: function () { return tools_1.ToolHandler; } });
+// Surface a few daemon-mode bits for tests + diagnostics.
+var daemon_2 = require("./daemon");
+Object.defineProperty(exports, "Daemon", { enumerable: true, get: function () { return daemon_2.Daemon; } });
+var version_1 = require("./version");
+Object.defineProperty(exports, "CodeGraphPackageVersion", { enumerable: true, get: function () { return version_1.CodeGraphPackageVersion; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"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"}

package/dist/mcp/proxy.d.ts

@@ -0,0 +1,46 @@
+/**
+ * MCP proxy mode — issue #411.
+ *
+ * The proxy is a near-transparent stdio↔socket pipe. Once it has verified
+ * the daemon's hello line (same major.minor.patch as ours), it does no
+ * protocol parsing of its own: every byte the MCP host writes to the proxy's
+ * stdin goes straight to the daemon socket, and every byte the daemon emits
+ * goes straight to the host's stdout. Server-initiated JSON-RPC requests
+ * (e.g. `roots/list`) flow through the same pipe transparently.
+ *
+ * Lifecycle expectations:
+ *   - The proxy exits when *either* stream closes (host stdin closed →
+ *     daemon socket end, or daemon-side socket close → host stdout end).
+ *   - Closing the socket on the proxy side is what tells the daemon to
+ *     decrement its connected-clients refcount.
+ *   - On a parent-process death we can't detect via stdin close (e.g. SIGKILL
+ *     of the MCP host), the proxy's PPID watchdog catches it — same logic
+ *     the direct-mode server uses; see issue #277.
+ */
+export interface ProxyResult {
+    /**
+     * `proxied` — successfully attached to a same-version daemon and piped
+     * stdio. The proxy stays alive until either end closes.
+     * `fallback-needed` — the daemon rejected us (version mismatch / unreachable
+     * socket) and the caller should run the server in direct mode.
+     */
+    outcome: 'proxied' | 'fallback-needed';
+    reason?: string;
+}
+/**
+ * Attempt to connect to the daemon at `socketPath` and pipe stdio through it.
+ *
+ * Returns a promise that resolves when either:
+ *   - the connection succeeded and one of stdin/socket has now closed
+ *     (after which the process should exit), or
+ *   - the connection failed early enough that the caller can still fall
+ *     back to direct mode.
+ *
+ * The `expectedVersion` param defaults to the package's own version — daemon
+ * and proxy MUST match exactly. Mismatch resolves with
+ * `outcome: 'fallback-needed'` so the caller can transparently start its own
+ * server. (We accept the cost of two concurrent servers in this case as the
+ * price of never silently running a stale daemon against newer client code.)
+ */
+export declare function runProxy(socketPath: string, expectedVersion?: string): Promise<ProxyResult>;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/mcp/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/mcp/proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,EAAE,SAAS,GAAG,iBAAiB,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,MAAM,EAClB,eAAe,GAAE,MAAgC,GAChD,OAAO,CAAC,WAAW,CAAC,CAsCtB"}