@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/api/workbench-vfs-routes.js

@@ -0,0 +1,396 @@
+import crypto from "node:crypto";
+import { buildStoreVariantBlockedMessage, isLocalCodeExecutionAllowed, } from "@elizaos/core";
+import { PostWorkbenchVfsCompilePluginRequestSchema, PostWorkbenchVfsGitRequestSchema, PostWorkbenchVfsLoadPluginRequestSchema, PostWorkbenchVfsProjectRequestSchema, PostWorkbenchVfsPromoteToCloudRequestSchema, PostWorkbenchVfsRollbackRequestSchema, PostWorkbenchVfsSnapshotRequestSchema, PutWorkbenchVfsFileRequestSchema, } from "@elizaos/shared";
+import { getLoadedVfsPluginViews, loadPluginFromVfs, unloadPluginFromVfs, } from "../runtime/load-plugin-from-vfs.js";
+import { createPluginCompiler, } from "../services/plugin-compiler.js";
+import { createVfsGitService, VfsGitError } from "../services/vfs-git.js";
+import { createVirtualFilesystemService, VirtualFilesystemError, } from "../services/virtual-filesystem.js";
+export async function handleWorkbenchVfsRoutes(ctx) {
+    const { req, res, method, pathname, url, json, error, readJsonBody } = ctx;
+    if (method === "GET" && pathname === "/api/workbench/vfs/plugins") {
+        json(res, { plugins: getLoadedVfsPluginViews() });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/workbench/vfs/projects") {
+        const raw = await readJsonBody(req, res);
+        if (raw === null)
+            return true;
+        const parsed = PostWorkbenchVfsProjectRequestSchema.safeParse(raw);
+        if (!parsed.success) {
+            error(res, parsed.error.issues[0]?.message ?? "projectId is required", 400);
+            return true;
+        }
+        try {
+            const vfs = await openProject(parsed.data.projectId);
+            json(res, {
+                project: projectView(vfs),
+                quota: await vfs.quota(),
+            }, 201);
+        }
+        catch (err) {
+            sendVfsError(ctx, err);
+        }
+        return true;
+    }
+    const match = /^\/api\/workbench\/vfs\/projects\/([^/]+)(?:\/([^/]+)(?:\/([^/]+))?)?$/.exec(pathname);
+    if (!match)
+        return false;
+    const projectId = ctx.decodePathComponent(match[1], res, "VFS project id");
+    if (!projectId)
+        return true;
+    const section = match[2] ?? "";
+    const tail = match[3] ?? "";
+    try {
+        const vfs = await openProject(projectId);
+        if (method === "GET" && section === "quota") {
+            json(res, { quota: await vfs.quota() });
+            return true;
+        }
+        if (section === "files") {
+            if (method !== "GET") {
+                error(res, "Unsupported VFS files method", 405);
+                return true;
+            }
+            await handleFiles(ctx, vfs);
+            return true;
+        }
+        if (section === "file") {
+            await handleFile(ctx, vfs);
+            return true;
+        }
+        if (section === "snapshots") {
+            await handleSnapshots(ctx, vfs, tail);
+            return true;
+        }
+        if (method === "GET" && section === "diff") {
+            const before = url.searchParams.get("beforeSnapshotId");
+            const after = url.searchParams.get("afterSnapshotId");
+            const snapshotId = url.searchParams.get("snapshotId");
+            if (before && after) {
+                json(res, { diff: await vfs.diffSnapshots(before, after) });
+                return true;
+            }
+            if (!snapshotId) {
+                error(res, "snapshotId is required", 400);
+                return true;
+            }
+            json(res, { diff: await vfs.diffCurrent(snapshotId) });
+            return true;
+        }
+        if (method === "POST" && section === "rollback") {
+            const raw = await readJsonBody(req, res);
+            if (raw === null)
+                return true;
+            const parsed = PostWorkbenchVfsRollbackRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                error(res, parsed.error.issues[0]?.message ?? "snapshotId is required", 400);
+                return true;
+            }
+            json(res, { rollback: await vfs.rollback(parsed.data.snapshotId) });
+            return true;
+        }
+        if (method === "POST" && section === "git") {
+            const raw = await readJsonBody(req, res);
+            if (raw === null)
+                return true;
+            const parsed = PostWorkbenchVfsGitRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                error(res, parsed.error.issues[0]?.message ?? "Invalid VFS Git request", 400);
+                return true;
+            }
+            const git = createVfsGitService(vfs);
+            json(res, { git: await git.run(parsed.data) });
+            return true;
+        }
+        if (method === "POST" && section === "compile-plugin") {
+            if (!isLocalCodeExecutionAllowed()) {
+                error(res, buildStoreVariantBlockedMessage("VFS plugin compilation"), 403);
+                return true;
+            }
+            const raw = await readJsonBody(req, res);
+            if (raw === null)
+                return true;
+            const parsed = PostWorkbenchVfsCompilePluginRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                error(res, parsed.error.issues[0]?.message ?? "Invalid compile request", 400);
+                return true;
+            }
+            const compiler = createPluginCompiler();
+            const result = await compiler.compile({
+                vfs,
+                projectId,
+                entry: parsed.data.entry,
+                ...(parsed.data.outFile ? { outFile: parsed.data.outFile } : {}),
+                ...(parsed.data.format
+                    ? { format: parsed.data.format }
+                    : {}),
+                ...(parsed.data.target ? { target: parsed.data.target } : {}),
+            });
+            json(res, { compile: result });
+            return true;
+        }
+        if (method === "POST" && section === "load-plugin") {
+            if (!isLocalCodeExecutionAllowed()) {
+                error(res, buildStoreVariantBlockedMessage("VFS plugin loading"), 403);
+                return true;
+            }
+            if (!ctx.state.runtime) {
+                error(res, "Agent runtime is not available", 503);
+                return true;
+            }
+            const raw = await readJsonBody(req, res);
+            if (raw === null)
+                return true;
+            const parsed = PostWorkbenchVfsLoadPluginRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                error(res, parsed.error.issues[0]?.message ?? "Invalid load request", 400);
+                return true;
+            }
+            const result = await loadPluginFromVfs({
+                runtime: ctx.state.runtime,
+                vfs,
+                projectId,
+                entry: parsed.data.entry,
+                ...(parsed.data.outFile ? { outFile: parsed.data.outFile } : {}),
+                ...(typeof parsed.data.compileFirst === "boolean"
+                    ? { compileFirst: parsed.data.compileFirst }
+                    : {}),
+            });
+            json(res, result);
+            return true;
+        }
+        if (method === "DELETE" && section === "plugins" && tail) {
+            if (!isLocalCodeExecutionAllowed()) {
+                error(res, buildStoreVariantBlockedMessage("VFS plugin unloading"), 403);
+                return true;
+            }
+            if (!ctx.state.runtime) {
+                error(res, "Agent runtime is not available", 503);
+                return true;
+            }
+            const pluginName = ctx.decodePathComponent(tail, res, "plugin name");
+            if (!pluginName)
+                return true;
+            json(res, await unloadPluginFromVfs({
+                runtime: ctx.state.runtime,
+                pluginName,
+            }));
+            return true;
+        }
+        if (method === "POST" && section === "promote-to-cloud") {
+            if (!ctx.state.runtime) {
+                error(res, "Agent runtime is not available", 503);
+                return true;
+            }
+            const cloud = getCloudCodingContainerService(ctx.state.runtime);
+            if (!cloud) {
+                error(res, "Cloud coding-container service is not available", 503);
+                return true;
+            }
+            const raw = await readJsonBody(req, res);
+            if (raw === null)
+                return true;
+            const parsed = PostWorkbenchVfsPromoteToCloudRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                error(res, parsed.error.issues[0]?.message ?? "Invalid cloud promotion request", 400);
+                return true;
+            }
+            const bundle = await exportVfsBundle(vfs, projectId, parsed.data.snapshotId);
+            const request = {
+                source: bundle,
+                ...(parsed.data.name ? { name: parsed.data.name } : {}),
+                ...(parsed.data.description
+                    ? { description: parsed.data.description }
+                    : {}),
+                ...(parsed.data.preferredAgent
+                    ? { preferredAgent: parsed.data.preferredAgent }
+                    : {}),
+                ...(parsed.data.workspacePath || parsed.data.branchName
+                    ? {
+                        target: {
+                            ...(parsed.data.workspacePath
+                                ? { workspacePath: parsed.data.workspacePath }
+                                : {}),
+                            ...(parsed.data.branchName
+                                ? { branchName: parsed.data.branchName }
+                                : {}),
+                        },
+                    }
+                    : {}),
+                ...(parsed.data.metadata ? { metadata: parsed.data.metadata } : {}),
+            };
+            try {
+                json(res, await cloud.promoteVfsToCloudContainer(request), 202);
+            }
+            catch (err) {
+                const status = typeof err?.statusCode === "number"
+                    ? err.statusCode
+                    : 500;
+                error(res, err instanceof Error ? err.message : String(err), status);
+            }
+            return true;
+        }
+        error(res, "VFS route not found", 404);
+        return true;
+    }
+    catch (err) {
+        sendVfsError(ctx, err);
+        return true;
+    }
+}
+async function handleFiles(ctx, vfs) {
+    const path = ctx.url.searchParams.get("path") ?? ".";
+    const recursive = ctx.url.searchParams.get("recursive") === "true";
+    ctx.json(ctx.res, { files: await vfs.list(path, { recursive }) });
+}
+async function handleFile(ctx, vfs) {
+    const { req, res, method, url, json, error, readJsonBody } = ctx;
+    const queryPath = url.searchParams.get("path");
+    if (method !== "PUT" && !queryPath) {
+        error(res, "path query parameter is required", 400);
+        return;
+    }
+    if (method === "GET") {
+        const encoding = url.searchParams.get("encoding") === "base64" ? "base64" : "utf-8";
+        if (encoding === "base64") {
+            const bytes = await vfs.readFileBytes(queryPath ?? "");
+            json(res, {
+                path: vfs.resolveVirtualPath(queryPath ?? ""),
+                encoding,
+                content: Buffer.from(bytes).toString("base64"),
+            });
+            return;
+        }
+        json(res, {
+            path: vfs.resolveVirtualPath(queryPath ?? ""),
+            encoding,
+            content: await vfs.readFile(queryPath ?? ""),
+        });
+        return;
+    }
+    if (method === "PUT") {
+        const raw = await readJsonBody(req, res);
+        if (raw === null)
+            return;
+        const parsed = PutWorkbenchVfsFileRequestSchema.safeParse(raw);
+        if (!parsed.success) {
+            error(res, parsed.error.issues[0]?.message ?? "Invalid file request", 400);
+            return;
+        }
+        const data = parsed.data.encoding === "base64"
+            ? Buffer.from(parsed.data.content, "base64")
+            : parsed.data.content;
+        json(res, { file: await vfs.writeFile(parsed.data.path, data) });
+        return;
+    }
+    if (method === "DELETE") {
+        await vfs.delete(queryPath ?? "", { recursive: true });
+        json(res, { ok: true });
+        return;
+    }
+    error(res, "Unsupported VFS file method", 405);
+}
+async function handleSnapshots(ctx, vfs, snapshotId) {
+    const { req, res, method, json, error, readJsonBody } = ctx;
+    if (method === "GET" && snapshotId) {
+        const decoded = ctx.decodePathComponent(snapshotId, res, "snapshot id");
+        if (!decoded)
+            return;
+        json(res, { snapshot: snapshotView(await vfs.getSnapshot(decoded)) });
+        return;
+    }
+    if (method === "GET") {
+        json(res, { snapshots: (await vfs.listSnapshots()).map(snapshotView) });
+        return;
+    }
+    if (method === "POST") {
+        const raw = await readJsonBody(req, res);
+        if (raw === null)
+            return;
+        const parsed = PostWorkbenchVfsSnapshotRequestSchema.safeParse(raw);
+        if (!parsed.success) {
+            error(res, parsed.error.issues[0]?.message ?? "Invalid snapshot request", 400);
+            return;
+        }
+        json(res, { snapshot: snapshotView(await vfs.createSnapshot(parsed.data.note)) }, 201);
+        return;
+    }
+    error(res, "Unsupported VFS snapshot method", 405);
+}
+async function openProject(projectId) {
+    const vfs = createVirtualFilesystemService({ projectId });
+    await vfs.initialize();
+    return vfs;
+}
+function projectView(vfs) {
+    return {
+        projectId: vfs.projectId,
+    };
+}
+function snapshotView(snapshot) {
+    const { root: _root, ...view } = snapshot;
+    return view;
+}
+function sendVfsError(ctx, err) {
+    if (err instanceof VirtualFilesystemError) {
+        const status = err.code === "NOT_FOUND" || err.code === "SNAPSHOT_NOT_FOUND"
+            ? 404
+            : err.code === "QUOTA_EXCEEDED"
+                ? 413
+                : 400;
+        ctx.error(ctx.res, err.message, status);
+        return;
+    }
+    if (err instanceof VfsGitError) {
+        const status = err.code === "SYMLINK_DENIED"
+            ? 422
+            : err.code === "INVALID_GIT_URL" ||
+                err.code === "INVALID_GIT_PATH" ||
+                err.code === "MISSING_ARGUMENT"
+                ? 400
+                : 500;
+        ctx.error(ctx.res, err.message, status);
+        return;
+    }
+    ctx.error(ctx.res, err instanceof Error ? err.message : String(err), 500);
+}
+function getCloudCodingContainerService(runtime) {
+    const service = runtime.getService("CLOUD_CONTAINER") ??
+        runtime.getService("cloud-container") ??
+        runtime.getService("cloudContainer");
+    if (!service || typeof service !== "object")
+        return null;
+    const candidate = service;
+    return typeof candidate.promoteVfsToCloudContainer === "function"
+        ? candidate
+        : null;
+}
+async function exportVfsBundle(vfs, projectId, snapshotId) {
+    const snapshot = snapshotId
+        ? await vfs.getSnapshot(snapshotId)
+        : await vfs.createSnapshot("promote-to-cloud");
+    const entries = await vfs.exportFiles(snapshot.id);
+    const files = await Promise.all(entries.map(async (entry) => {
+        const bytes = entry.bytes;
+        return {
+            path: entry.path,
+            contents: Buffer.from(bytes).toString("base64"),
+            encoding: "base64",
+            size: bytes.byteLength,
+            sha256: crypto.createHash("sha256").update(bytes).digest("hex"),
+            mtimeMs: entry.mtimeMs,
+        };
+    }));
+    const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
+    return {
+        sourceKind: "project",
+        projectId,
+        snapshotId: snapshot.id,
+        revision: snapshot.id,
+        files,
+        manifest: {
+            fileCount: files.length,
+            totalBytes,
+        },
+    };
+}

package/api/ws-event-replay.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Pure helpers for the WebSocket event-buffer replay on (re)connect.
+ *
+ * Extracted from server.ts so the cursor-replay slice logic can be unit-tested
+ * in isolation. See loadperf research report 05 (Network & Data Sync),
+ * Finding 4: on every (re)connect the server replays the tail of
+ * `state.eventBuffer`, re-flooding the client with up to `DEFAULT_REPLAY_LIMIT`
+ * historical envelopes even after a brief reconnect. A client that tracks the
+ * highest event sequence it has applied can pass it back as a cursor so the
+ * server replays only the envelopes the client is actually missing.
+ *
+ * @module
+ */
+/**
+ * Maximum number of buffered envelopes replayed when the client provides no
+ * (or an invalid) cursor. This is the historical, backward-compatible default:
+ * a fresh connection with no cursor receives `buffer.slice(-DEFAULT_REPLAY_LIMIT)`.
+ */
+export declare const DEFAULT_REPLAY_LIMIT = 120;
+/**
+ * Minimal shape the replay logic needs from a buffered event envelope. The real
+ * envelope (`StreamEventEnvelope` from `@elizaos/shared`) carries more fields;
+ * the cursor only cares about the monotonic sequence, which is the integer
+ * portion of `eventId` (`evt-<n>`) and is mirrored on `bufferSeq` for envelopes
+ * pushed through the primary `pushEvent` path.
+ */
+export interface ReplayableEvent {
+    eventId: string;
+    bufferSeq?: number;
+}
+/**
+ * Resolve the monotonic sequence of a buffered envelope.
+ *
+ * Prefers the explicit numeric `bufferSeq` (stamped by `pushEvent`); falls back
+ * to parsing the trailing integer of `eventId` (`evt-<n>`) so envelopes pushed
+ * by other code paths (e.g. the `/api/agent-event` REST mirror) still sort and
+ * filter correctly. Returns `null` when no sequence can be derived.
+ */
+export declare function eventSequence(event: ReplayableEvent): number | null;
+/**
+ * Parse a client-supplied reconnect cursor (the `lastEventId` WS query param).
+ *
+ * Accepts either a bare integer (`"42"`) or the full envelope id (`"evt-42"`),
+ * since a client may track whichever form it received. Returns the numeric
+ * sequence the client has already applied, or `null` when the cursor is absent
+ * or not a valid non-negative integer — in which case the caller falls back to
+ * the default tail replay (backward-compatible: no cursor => prior behavior).
+ */
+export declare function parseEventCursor(raw: string | null | undefined): number | null;
+/**
+ * Select the envelopes to replay to a (re)connecting client.
+ *
+ * - With a valid `cursor`, returns only envelopes whose sequence is strictly
+ *   greater than the cursor (the events the client is missing), preserving
+ *   buffer order and capped to the `limit` most recent so a stale cursor can
+ *   never replay an unbounded burst.
+ * - With `cursor === null` (absent/invalid), returns `buffer.slice(-limit)` —
+ *   the exact historical behavior, so clients that send no cursor are
+ *   unaffected.
+ *
+ * Does not mutate the input buffer and does not reorder events.
+ */
+export declare function selectReplayEvents<T extends ReplayableEvent>(buffer: readonly T[], cursor: number | null, limit?: number): T[];
+//# sourceMappingURL=ws-event-replay.d.ts.map

package/api/ws-event-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-event-replay.d.ts","sourceRoot":"","sources":["../../src/api/ws-event-replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAYnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC7B,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,eAAe,EAC1D,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,GAAE,MAA6B,GACnC,CAAC,EAAE,CAUL"}

package/api/ws-event-replay.js

@@ -0,0 +1,84 @@
+/**
+ * Pure helpers for the WebSocket event-buffer replay on (re)connect.
+ *
+ * Extracted from server.ts so the cursor-replay slice logic can be unit-tested
+ * in isolation. See loadperf research report 05 (Network & Data Sync),
+ * Finding 4: on every (re)connect the server replays the tail of
+ * `state.eventBuffer`, re-flooding the client with up to `DEFAULT_REPLAY_LIMIT`
+ * historical envelopes even after a brief reconnect. A client that tracks the
+ * highest event sequence it has applied can pass it back as a cursor so the
+ * server replays only the envelopes the client is actually missing.
+ *
+ * @module
+ */
+/**
+ * Maximum number of buffered envelopes replayed when the client provides no
+ * (or an invalid) cursor. This is the historical, backward-compatible default:
+ * a fresh connection with no cursor receives `buffer.slice(-DEFAULT_REPLAY_LIMIT)`.
+ */
+export const DEFAULT_REPLAY_LIMIT = 120;
+/**
+ * Resolve the monotonic sequence of a buffered envelope.
+ *
+ * Prefers the explicit numeric `bufferSeq` (stamped by `pushEvent`); falls back
+ * to parsing the trailing integer of `eventId` (`evt-<n>`) so envelopes pushed
+ * by other code paths (e.g. the `/api/agent-event` REST mirror) still sort and
+ * filter correctly. Returns `null` when no sequence can be derived.
+ */
+export function eventSequence(event) {
+    if (typeof event.bufferSeq === "number" &&
+        Number.isSafeInteger(event.bufferSeq) &&
+        event.bufferSeq >= 0) {
+        return event.bufferSeq;
+    }
+    const match = /(\d+)\s*$/.exec(event.eventId);
+    if (!match)
+        return null;
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+/**
+ * Parse a client-supplied reconnect cursor (the `lastEventId` WS query param).
+ *
+ * Accepts either a bare integer (`"42"`) or the full envelope id (`"evt-42"`),
+ * since a client may track whichever form it received. Returns the numeric
+ * sequence the client has already applied, or `null` when the cursor is absent
+ * or not a valid non-negative integer — in which case the caller falls back to
+ * the default tail replay (backward-compatible: no cursor => prior behavior).
+ */
+export function parseEventCursor(raw) {
+    if (raw == null)
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const match = /(\d+)\s*$/.exec(trimmed);
+    if (!match)
+        return null;
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+/**
+ * Select the envelopes to replay to a (re)connecting client.
+ *
+ * - With a valid `cursor`, returns only envelopes whose sequence is strictly
+ *   greater than the cursor (the events the client is missing), preserving
+ *   buffer order and capped to the `limit` most recent so a stale cursor can
+ *   never replay an unbounded burst.
+ * - With `cursor === null` (absent/invalid), returns `buffer.slice(-limit)` —
+ *   the exact historical behavior, so clients that send no cursor are
+ *   unaffected.
+ *
+ * Does not mutate the input buffer and does not reorder events.
+ */
+export function selectReplayEvents(buffer, cursor, limit = DEFAULT_REPLAY_LIMIT) {
+    const cap = limit > 0 ? limit : 0;
+    if (cursor === null) {
+        return cap >= buffer.length ? buffer.slice() : buffer.slice(-cap);
+    }
+    const missing = buffer.filter((event) => {
+        const seq = eventSequence(event);
+        return seq !== null && seq > cursor;
+    });
+    return missing.length > cap ? missing.slice(-cap) : missing;
+}

package/api/x-relay-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x-relay-routes.d.ts","sourceRoot":"","sources":["../../src/api/x-relay-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,eAAe,CAAC;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,UAAU,aAAa;IACrB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAChD,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,GAAG,IAAI,CAAC;IACT,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAChC;AA6HD,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,OAAO,CAAC,CAsElB"}