@bolt-foundry/gambit 0.8.5 → 0.8.6-rc.1

package/esm/src/graphql_subscription_stream.js

@@ -0,0 +1,510 @@
+import { appendDurableStreamEvent, deleteDurableStream, getDurableStreamNextOffset, readDurableStreamEvents, subscribeDurableStream, } from "./durable_streams.js";
+import { gambitSimulatorSchema, } from "./simulator_graphql.js";
+import { getOperationAST, parse, subscribe, validate, } from "graphql";
+const GRAPHQL_STREAM_SESSION_PREFIX = "graphql-subscriptions:";
+const SESSION_IDLE_TTL_MS = 2 * 60 * 1000;
+const HEARTBEAT_MS = 15 * 1000;
+const sessions = new Map();
+function getOrCreateSession(sessionId) {
+    const existing = sessions.get(sessionId);
+    if (existing)
+        return existing;
+    const created = {
+        sessionId,
+        streamId: `${GRAPHQL_STREAM_SESSION_PREFIX}${sessionId}`,
+        activeSubscriptions: new Map(),
+        liveConnections: 0,
+        cleanupTimer: null,
+    };
+    sessions.set(sessionId, created);
+    return created;
+}
+function stopCleanupTimer(session) {
+    if (session.cleanupTimer === null)
+        return;
+    clearTimeout(session.cleanupTimer);
+    session.cleanupTimer = null;
+}
+function scheduleCleanupIfIdle(session) {
+    if (session.liveConnections > 0)
+        return;
+    if (session.cleanupTimer !== null)
+        return;
+    if (session.activeSubscriptions.size === 0) {
+        sessions.delete(session.sessionId);
+        deleteDurableStream(session.streamId);
+        return;
+    }
+    session.cleanupTimer = setTimeout(() => {
+        session.cleanupTimer = null;
+        if (session.liveConnections > 0)
+            return;
+        const subscriptionIds = [...session.activeSubscriptions.keys()];
+        void (async () => {
+            for (const subscriptionId of subscriptionIds) {
+                await stopSubscription(session, subscriptionId, "session_idle_timeout");
+            }
+            if (session.liveConnections === 0 && session.activeSubscriptions.size === 0) {
+                sessions.delete(session.sessionId);
+                deleteDurableStream(session.streamId);
+            }
+        })();
+    }, SESSION_IDLE_TTL_MS);
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeGraphqlErrors(errors) {
+    if (!errors || errors.length === 0)
+        return undefined;
+    return errors.map((error) => ({
+        message: error.message,
+        path: Array.isArray(error.path) ? [...error.path] : undefined,
+        code: typeof error.extensions?.["code"] === "string"
+            ? error.extensions["code"]
+            : undefined,
+    }));
+}
+function makeOperationId(query, operationName, variables) {
+    const raw = `${operationName ?? "anonymous"}:${query}:${JSON.stringify(variables ?? {})}`;
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < raw.length; i += 1) {
+        hash ^= raw.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `op_${(hash >>> 0).toString(16)}`;
+}
+function appendEnvelope(session, payload) {
+    const appended = appendDurableStreamEvent(session.streamId, {
+        ...payload,
+        createdAt: new Date().toISOString(),
+    });
+    return appended.offset;
+}
+function formatSse(event) {
+    const eventName = event.data && typeof event.data === "object" &&
+        !Array.isArray(event.data) &&
+        typeof event.data.type === "string"
+        ? event.data.type
+        : "graphql.stream";
+    return `id: ${event.offset}\nevent: ${eventName}\ndata: ${JSON.stringify(event.data)}\n\n`;
+}
+function asNumberOrNull(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return null;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function parseControlRequest(payload) {
+    if (!isRecord(payload))
+        return null;
+    const action = payload.action;
+    if (action === "subscribe") {
+        if (typeof payload.sessionId !== "string" ||
+            typeof payload.subscriptionId !== "string" ||
+            typeof payload.query !== "string") {
+            return null;
+        }
+        const variables = isRecord(payload.variables)
+            ? payload.variables
+            : undefined;
+        return {
+            action,
+            sessionId: payload.sessionId.trim(),
+            subscriptionId: payload.subscriptionId.trim(),
+            query: payload.query,
+            variables,
+            operationName: typeof payload.operationName === "string"
+                ? payload.operationName
+                : undefined,
+        };
+    }
+    if (action === "unsubscribe") {
+        if (typeof payload.sessionId !== "string" ||
+            typeof payload.subscriptionId !== "string") {
+            return null;
+        }
+        return {
+            action,
+            sessionId: payload.sessionId.trim(),
+            subscriptionId: payload.subscriptionId.trim(),
+        };
+    }
+    if (action === "close") {
+        if (typeof payload.sessionId !== "string")
+            return null;
+        return {
+            action,
+            sessionId: payload.sessionId.trim(),
+        };
+    }
+    return null;
+}
+async function stopSubscription(session, subscriptionId, reason) {
+    const active = session.activeSubscriptions.get(subscriptionId);
+    if (!active)
+        return false;
+    active.stopReason = reason;
+    session.activeSubscriptions.delete(subscriptionId);
+    try {
+        await settleIteratorReturn(active.iterator);
+    }
+    catch {
+        // Best-effort iterator cleanup.
+    }
+    appendEnvelope(session, {
+        type: "unsubscribed",
+        sessionId: session.sessionId,
+        subscriptionId,
+        operationId: active.operationId,
+        operationName: active.operationName,
+        reason,
+    });
+    scheduleCleanupIfIdle(session);
+    return true;
+}
+async function settleIteratorReturn(iterator) {
+    if (typeof iterator.return !== "function")
+        return;
+    let timeout = null;
+    try {
+        await Promise.race([
+            Promise.resolve(iterator.return?.()).then(() => { }).catch(() => { }),
+            new Promise((resolve) => {
+                timeout = setTimeout(resolve, 250);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function runSubscriptionPump(session, active) {
+    try {
+        while (session.activeSubscriptions.get(active.subscriptionId) === active) {
+            const next = await active.iterator.next();
+            if (next.done)
+                break;
+            const payload = next.value;
+            appendEnvelope(session, {
+                type: "next",
+                sessionId: session.sessionId,
+                subscriptionId: active.subscriptionId,
+                operationId: active.operationId,
+                operationName: active.operationName,
+                payload: payload.data ?? null,
+                errors: normalizeGraphqlErrors(payload.errors),
+            });
+        }
+    }
+    catch (error) {
+        appendEnvelope(session, {
+            type: "error",
+            sessionId: session.sessionId,
+            subscriptionId: active.subscriptionId,
+            operationId: active.operationId,
+            operationName: active.operationName,
+            reason: "subscription_pump_failed",
+            errors: [{
+                    message: error instanceof Error ? error.message : String(error),
+                }],
+        });
+    }
+    finally {
+        const current = session.activeSubscriptions.get(active.subscriptionId);
+        if (current === active) {
+            session.activeSubscriptions.delete(active.subscriptionId);
+            appendEnvelope(session, {
+                type: "complete",
+                sessionId: session.sessionId,
+                subscriptionId: active.subscriptionId,
+                operationId: active.operationId,
+                operationName: active.operationName,
+                reason: active.stopReason ?? "completed",
+            });
+        }
+        scheduleCleanupIfIdle(session);
+    }
+}
+async function handleSubscribeControl(_request, session, control, context) {
+    const query = control.query.trim();
+    if (!query) {
+        return new Response(JSON.stringify({ ok: false, error: "missing_query" }), { status: 400, headers: { "content-type": "application/json" } });
+    }
+    if (!control.subscriptionId) {
+        return new Response(JSON.stringify({ ok: false, error: "missing_subscription_id" }), { status: 400, headers: { "content-type": "application/json" } });
+    }
+    const operationName = control.operationName?.trim() || null;
+    const operationId = makeOperationId(query, operationName, control.variables);
+    await stopSubscription(session, control.subscriptionId, "replaced");
+    let document;
+    try {
+        document = parse(query);
+    }
+    catch (error) {
+        appendEnvelope(session, {
+            type: "error",
+            sessionId: session.sessionId,
+            subscriptionId: control.subscriptionId,
+            operationId,
+            operationName,
+            reason: "invalid_graphql_query",
+            errors: [{
+                    message: error instanceof Error ? error.message : String(error),
+                }],
+        });
+        return new Response(JSON.stringify({ ok: false, error: "invalid_graphql_query" }), { status: 400, headers: { "content-type": "application/json" } });
+    }
+    const validationErrors = validate(gambitSimulatorSchema, document);
+    if (validationErrors.length > 0) {
+        appendEnvelope(session, {
+            type: "error",
+            sessionId: session.sessionId,
+            subscriptionId: control.subscriptionId,
+            operationId,
+            operationName,
+            reason: "subscription_validation_failed",
+            errors: normalizeGraphqlErrors(validationErrors),
+        });
+        return new Response(JSON.stringify({ ok: false, error: "subscription_validation_failed" }), { status: 400, headers: { "content-type": "application/json" } });
+    }
+    const operation = getOperationAST(document, operationName ?? undefined);
+    if (!operation || operation.operation !== "subscription") {
+        appendEnvelope(session, {
+            type: "error",
+            sessionId: session.sessionId,
+            subscriptionId: control.subscriptionId,
+            operationId,
+            operationName,
+            reason: "operation_must_be_subscription",
+        });
+        return new Response(JSON.stringify({ ok: false, error: "operation_must_be_subscription" }), { status: 400, headers: { "content-type": "application/json" } });
+    }
+    let iterator;
+    try {
+        const subscribed = await subscribe({
+            schema: gambitSimulatorSchema,
+            document,
+            contextValue: context,
+            variableValues: control.variables,
+            operationName: operationName ?? undefined,
+        });
+        if (!isAsyncIterable(subscribed)) {
+            const single = subscribed;
+            appendEnvelope(session, {
+                type: "error",
+                sessionId: session.sessionId,
+                subscriptionId: control.subscriptionId,
+                operationId,
+                operationName,
+                reason: "subscription_start_failed",
+                payload: single.data ?? null,
+                errors: normalizeGraphqlErrors(single.errors),
+            });
+            return new Response(JSON.stringify({ ok: false, error: "subscription_start_failed" }), { status: 400, headers: { "content-type": "application/json" } });
+        }
+        iterator = subscribed[Symbol.asyncIterator]();
+    }
+    catch (error) {
+        appendEnvelope(session, {
+            type: "error",
+            sessionId: session.sessionId,
+            subscriptionId: control.subscriptionId,
+            operationId,
+            operationName,
+            reason: "subscription_start_failed",
+            errors: [{
+                    message: error instanceof Error ? error.message : String(error),
+                }],
+        });
+        return new Response(JSON.stringify({ ok: false, error: "subscription_start_failed" }), { status: 500, headers: { "content-type": "application/json" } });
+    }
+    const active = {
+        subscriptionId: control.subscriptionId,
+        operationId,
+        operationName,
+        iterator,
+        stopReason: null,
+    };
+    session.activeSubscriptions.set(control.subscriptionId, active);
+    stopCleanupTimer(session);
+    appendEnvelope(session, {
+        type: "subscribed",
+        sessionId: session.sessionId,
+        subscriptionId: control.subscriptionId,
+        operationId,
+        operationName,
+    });
+    void runSubscriptionPump(session, active);
+    return new Response(JSON.stringify({
+        ok: true,
+        nextOffset: getDurableStreamNextOffset(session.streamId),
+    }), {
+        status: 202,
+        headers: { "content-type": "application/json" },
+    });
+}
+async function handleUnsubscribeControl(session, control) {
+    const removed = await stopSubscription(session, control.subscriptionId, "unsubscribed_by_client");
+    return new Response(JSON.stringify({
+        ok: true,
+        removed,
+        nextOffset: getDurableStreamNextOffset(session.streamId),
+    }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+    });
+}
+async function handleCloseControl(session) {
+    const subscriptionIds = [...session.activeSubscriptions.keys()];
+    for (const subscriptionId of subscriptionIds) {
+        await stopSubscription(session, subscriptionId, "session_closed");
+    }
+    const nextOffset = getDurableStreamNextOffset(session.streamId);
+    if (session.liveConnections === 0 && session.activeSubscriptions.size === 0) {
+        sessions.delete(session.sessionId);
+        deleteDurableStream(session.streamId);
+    }
+    return new Response(JSON.stringify({
+        ok: true,
+        nextOffset,
+    }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+    });
+}
+async function handleControlRequest(request, context) {
+    let payload;
+    try {
+        payload = await request.json();
+    }
+    catch {
+        return new Response(JSON.stringify({ ok: false, error: "invalid_json" }), {
+            status: 400,
+            headers: { "content-type": "application/json" },
+        });
+    }
+    const control = parseControlRequest(payload);
+    if (!control) {
+        return new Response(JSON.stringify({ ok: false, error: "invalid_request" }), {
+            status: 400,
+            headers: { "content-type": "application/json" },
+        });
+    }
+    if (!control.sessionId) {
+        return new Response(JSON.stringify({ ok: false, error: "missing_session_id" }), {
+            status: 400,
+            headers: { "content-type": "application/json" },
+        });
+    }
+    const session = getOrCreateSession(control.sessionId);
+    stopCleanupTimer(session);
+    if (control.action === "subscribe") {
+        return await handleSubscribeControl(request, session, control, context);
+    }
+    if (control.action === "unsubscribe") {
+        return await handleUnsubscribeControl(session, control);
+    }
+    return await handleCloseControl(session);
+}
+function handleSseRequest(request) {
+    const url = new URL(request.url);
+    const sessionId = url.searchParams.get("sessionId")?.trim() ?? "";
+    if (!sessionId) {
+        return new Response("sessionId is required", { status: 400 });
+    }
+    const session = getOrCreateSession(sessionId);
+    stopCleanupTimer(session);
+    session.liveConnections += 1;
+    const offsetFromQuery = asNumberOrNull(url.searchParams.get("offset"));
+    const offsetFromLastEventId = asNumberOrNull(request.headers.get("last-event-id"));
+    const startOffset = Math.max(0, offsetFromLastEventId !== null
+        ? offsetFromLastEventId + 1
+        : (offsetFromQuery ?? 0));
+    const replay = readDurableStreamEvents(session.streamId, startOffset);
+    const encoder = new TextEncoder();
+    let closed = false;
+    let unsubscribeLive = null;
+    let heartbeat = null;
+    const teardown = (controller) => {
+        if (closed)
+            return;
+        closed = true;
+        if (unsubscribeLive) {
+            unsubscribeLive();
+            unsubscribeLive = null;
+        }
+        if (heartbeat !== null) {
+            clearInterval(heartbeat);
+            heartbeat = null;
+        }
+        session.liveConnections = Math.max(0, session.liveConnections - 1);
+        scheduleCleanupIfIdle(session);
+        if (controller) {
+            try {
+                controller.close();
+            }
+            catch {
+                // No-op if already closed.
+            }
+        }
+    };
+    const stream = new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(": graphql stream open\n\n"));
+            for (const event of replay) {
+                controller.enqueue(encoder.encode(formatSse(event)));
+            }
+            unsubscribeLive = subscribeDurableStream(session.streamId, (event) => {
+                try {
+                    controller.enqueue(encoder.encode(formatSse(event)));
+                }
+                catch {
+                    teardown(controller);
+                }
+            });
+            heartbeat = setInterval(() => {
+                try {
+                    controller.enqueue(encoder.encode(": heartbeat\n\n"));
+                }
+                catch {
+                    teardown(controller);
+                }
+            }, HEARTBEAT_MS);
+            request.signal.addEventListener("abort", () => teardown(controller), {
+                once: true,
+            });
+        },
+        cancel() {
+            teardown();
+        },
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: {
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-cache, no-transform",
+            "connection": "keep-alive",
+            "x-graphql-stream-session": sessionId,
+            "stream-next-offset": String(getDurableStreamNextOffset(session.streamId)),
+        },
+    });
+}
+function isAsyncIterable(value) {
+    return !!value &&
+        typeof value[Symbol.asyncIterator] === "function";
+}
+export async function handleGraphqlSubscriptionStreamRequest(request, context) {
+    if (request.method === "GET") {
+        return await handleSseRequest(request);
+    }
+    if (request.method === "POST") {
+        return await handleControlRequest(request, context);
+    }
+    return new Response("Method not allowed", {
+        status: 405,
+        headers: { allow: "GET, POST" },
+    });
+}

package/esm/src/model_matchers.d.ts

@@ -5,6 +5,7 @@ export type ProviderMatchers = {
     matchesOllama: (model: string) => boolean;
     matchesGoogle: (model: string) => boolean;
     matchesCodex: (model: string) => boolean;
+    matchesClaudeCode: (model: string) => boolean;
 };
 export declare function createProviderMatchers(effectiveFallbackProvider: ProviderKey | null): ProviderMatchers;
 //# sourceMappingURL=model_matchers.d.ts.map

package/esm/src/model_matchers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model_matchers.d.ts","sourceRoot":"","sources":["../../src/src/model_matchers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AASzD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CAC1C,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,yBAAyB,EAAE,WAAW,GAAG,IAAI,GAC5C,gBAAgB,CAyBlB"}
+{"version":3,"file":"model_matchers.d.ts","sourceRoot":"","sources":["../../src/src/model_matchers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAazD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CAC/C,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,yBAAyB,EAAE,WAAW,GAAG,IAAI,GAC5C,gBAAgB,CAgClB"}

package/esm/src/model_matchers.js

@@ -2,14 +2,17 @@ import { GOOGLE_PREFIX } from "./providers/google.js";
 import { OLLAMA_PREFIX } from "./providers/ollama.js";
 import { OPENROUTER_PREFIX } from "./providers/openrouter.js";
 import { CODEX_PREFIX } from "./providers/codex.js";
+import { CLAUDE_CODE_ALIAS, CLAUDE_CODE_PREFIX, } from "./providers/claude_code.js";
 const LEGACY_CODEX_PREFIX = "codex/";
 const CODEX_PROVIDER_ALIAS = "codex-cli";
 export function createProviderMatchers(effectiveFallbackProvider) {
     const isUnprefixedModel = (model) => model.trim() !== CODEX_PROVIDER_ALIAS &&
+        model.trim() !== CLAUDE_CODE_ALIAS &&
         !model.startsWith(OPENROUTER_PREFIX) &&
         !model.startsWith(OLLAMA_PREFIX) &&
         !model.startsWith(GOOGLE_PREFIX) &&
         !model.startsWith(CODEX_PREFIX) &&
+        !model.startsWith(CLAUDE_CODE_PREFIX) &&
         !model.startsWith(LEGACY_CODEX_PREFIX);
     return {
         isUnprefixedModel,
@@ -22,5 +25,9 @@ export function createProviderMatchers(effectiveFallbackProvider) {
         matchesCodex: (model) => model.trim() === CODEX_PROVIDER_ALIAS ||
             model.startsWith(CODEX_PREFIX) ||
             (isUnprefixedModel(model) && effectiveFallbackProvider === "codex-cli"),
+        matchesClaudeCode: (model) => model.trim() === CLAUDE_CODE_ALIAS ||
+            model.startsWith(CLAUDE_CODE_PREFIX) ||
+            (isUnprefixedModel(model) &&
+                effectiveFallbackProvider === "claude-code-cli"),
     };
 }

package/esm/src/providers/claude_code.d.ts

@@ -0,0 +1,34 @@
+import type { ModelMessage, ModelProvider, SavedState } from "@bolt-foundry/gambit-core";
+export declare const CLAUDE_CODE_PREFIX = "claude-code-cli/";
+export declare const CLAUDE_CODE_ALIAS = "claude-code-cli";
+type CommandOutput = {
+    success: boolean;
+    code: number;
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+};
+type CommandRunner = (input: {
+    args: Array<string>;
+    cwd: string;
+    signal?: AbortSignal;
+    onStdoutLine?: (line: string) => void;
+}) => Promise<CommandOutput>;
+export declare function createClaudeCodeProvider(opts?: {
+    runCommand?: CommandRunner;
+}): ModelProvider;
+export declare function parseClaudeCodeArgsForTest(input: {
+    model: string;
+    state?: SavedState;
+    messages: Array<ModelMessage>;
+}): Array<string>;
+export declare function parseClaudeCodeStdoutForTest(stdout: string): {
+    assistantText: string;
+    sessionId?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+};
+export {};
+//# sourceMappingURL=claude_code.d.ts.map

package/esm/src/providers/claude_code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude_code.d.ts","sourceRoot":"","sources":["../../../src/src/providers/claude_code.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,YAAY,EACZ,aAAa,EAKb,UAAU,EACX,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,kBAAkB,qBAAqB,CAAC;AACrD,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAMnD,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE;IAC3B,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AA+c7B,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE;IAC9C,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B,GAAG,aAAa,CA4MhB;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;CAC/B,GAAG,KAAK,CAAC,MAAM,CAAC,CA2BhB;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG;IAC5D,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QACN,YAAY,EAAE,MAAM,CAAC;QACrB,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAEA"}