@alpacakit/agents 0.2.0-beta.2 → 0.2.0-beta.3

package/dist/agents/claude-session.js

@@ -1,419 +0,0 @@
-/**
- * Claude session adapter: one `claude -p --input-format stream-json
- * --output-format stream-json` process held open across turns.
- *
- * Protocol facts (claude 2.1.270, T52 / T61 lab runs):
- * - a turn is one user line `{"type":"user","message":{"role":"user","content":…}}`
- *   and ends with the `result` line; a user line written mid-turn is absorbed
- *   into the running turn at its next tool boundary (`steer`);
- * - `{"type":"control_request","request_id":…,"request":{"subtype":"interrupt"}}`
- *   is answered by a `control_response`, and the turn then ends with
- *   `is_error: true` / `terminal_reason: "aborted_tools"`;
- * - approval prompts reach stdout only with `--permission-prompt-tool stdio`, as
- *   `control_request` / `can_use_tool`, and are answered with a
- *   `control_response` whose `behavior` is `allow` (+ `updatedInput`) or `deny`;
- * - `--session-id <uuid>` fixes the id before the first turn (no `init` line
- *   is emitted until then), `--resume <id>` continues a recorded one;
- * - the child needs `USER` in its env: without it the CLI reports "Not logged in".
- */
-import { randomUUID } from "node:crypto";
-import path from "node:path";
-import { AGENT_ERROR_CODE, AgentError, TIMEOUT_KIND } from "../core/error.js";
-import { readJsonRecord, readNumber, readRecord, readString, } from "../core/json.js";
-import { redactSecrets } from "../core/redact.js";
-import { AGENT_EVENT_TYPE } from "../core/run.js";
-import { APPROVAL_DECISION, SESSION_EVENT_TYPE, SESSION_OWNER_KIND, TURN_OUTCOME, } from "../core/session.js";
-import { fileExists, readDirectoryNames, readJsonFile, scanJsonlFirstLast, } from "../host/session-files.js";
-import { assertHostSessionId, SessionProcess, SessionState, sessionStateError, } from "../kernel/session.js";
-import { CLAUDE, parseClaudeLine } from "./claude-stream.js";
-export const CLAUDE_PERMISSION_MODE = {
-    default: "default",
-    acceptEdits: "acceptEdits",
-    auto: "auto",
-    bypassPermissions: "bypassPermissions",
-    dontAsk: "dontAsk",
-    plan: "plan",
-};
-const CLAUDE_SESSION = {
-    cli: {
-        inputFormat: "--input-format",
-        permissionPromptTool: "--permission-prompt-tool",
-        stdio: "stdio",
-        resume: "--resume",
-        sessionId: "--session-id",
-        allowDangerouslySkipPermissions: "--allow-dangerously-skip-permissions",
-        /** The CLI spells the transcript's `default` mode `manual` on its flag. */
-        manualPermissionMode: "manual",
-    },
-    stream: {
-        type: {
-            user: "user",
-            assistant: "assistant",
-            result: "result",
-            controlRequest: "control_request",
-            controlResponse: "control_response",
-        },
-        field: {
-            type: "type",
-            message: "message",
-            role: "role",
-            content: "content",
-            request: "request",
-            requestId: "request_id",
-            response: "response",
-            subtype: "subtype",
-            error: "error",
-            toolName: "tool_name",
-            description: "description",
-            input: "input",
-            isError: "is_error",
-            result: "result",
-            behavior: "behavior",
-            updatedInput: "updatedInput",
-        },
-        subtype: {
-            interrupt: "interrupt",
-            canUseTool: "can_use_tool",
-            success: "success",
-            error: "error",
-        },
-        behavior: { allow: "allow", deny: "deny" },
-    },
-    files: {
-        root: ".claude",
-        projects: "projects",
-        sessions: "sessions",
-        transcriptExtension: ".jsonl",
-        registryExtension: ".json",
-        cwd: "cwd",
-        permissionMode: "permissionMode",
-        sessionId: "sessionId",
-        pid: "pid",
-        entrypoint: "entrypoint",
-    },
-};
-const CONTROL_RESPONSE_TIMEOUT_MS = 30_000;
-const DECLINED_MESSAGE = "Declined by the session owner";
-const CLAUDE_APPROVAL_DECISIONS = [
-    APPROVAL_DECISION.accept,
-    APPROVAL_DECISION.decline,
-];
-function sessionArgs(permissions, target, options) {
-    const mode = permissions.mode === CLAUDE_PERMISSION_MODE.default
-        ? CLAUDE_SESSION.cli.manualPermissionMode
-        : permissions.mode;
-    return [
-        CLAUDE.cli.prompt,
-        CLAUDE_SESSION.cli.inputFormat,
-        CLAUDE.cli.streamJson,
-        CLAUDE.cli.outputFormat,
-        CLAUDE.cli.streamJson,
-        CLAUDE.cli.verbose,
-        CLAUDE.cli.permissionMode,
-        mode,
-        ...(permissions.mode === CLAUDE_PERMISSION_MODE.bypassPermissions
-            ? [CLAUDE_SESSION.cli.allowDangerouslySkipPermissions]
-            : []),
-        CLAUDE_SESSION.cli.permissionPromptTool,
-        CLAUDE_SESSION.cli.stdio,
-        // A session's whole point is the recorded conversation, so `disabled`
-        // drops only the customization flags, never `--no-session-persistence`.
-        ...(options.customizations === "disabled"
-            ? [CLAUDE.cli.safeMode, CLAUDE.cli.strictMcpConfig]
-            : []),
-        target.kind === "resume"
-            ? CLAUDE_SESSION.cli.resume
-            : CLAUDE_SESSION.cli.sessionId,
-        target.sessionId,
-    ];
-}
-class ClaudeSession {
-    id;
-    process;
-    ctx;
-    state = new SessionState(CLAUDE.id);
-    pendingApprovals = new Map();
-    pendingControls = new Map();
-    reading;
-    turnCount = 0;
-    interruptRequested = false;
-    constructor(id, process, ctx) {
-        this.id = id;
-        this.process = process;
-        this.ctx = ctx;
-        this.reading = this.read();
-    }
-    get events() {
-        return this.state.events;
-    }
-    async send(text) {
-        this.state.requireIdle();
-        this.turnCount += 1;
-        const turn = this.state.beginTurn(String(this.turnCount));
-        this.writeUserLine(text);
-        return turn;
-    }
-    async steer(text) {
-        this.state.requireActive();
-        this.writeUserLine(text);
-    }
-    async interrupt() {
-        this.state.requireActive();
-        const requestId = randomUUID();
-        this.interruptRequested = true;
-        const answered = this.awaitControlResponse(requestId);
-        this.process.writeLine(JSON.stringify({
-            type: CLAUDE_SESSION.stream.type.controlRequest,
-            [CLAUDE_SESSION.stream.field.requestId]: requestId,
-            request: { subtype: CLAUDE_SESSION.stream.subtype.interrupt },
-        }));
-        try {
-            await answered;
-        }
-        catch (error) {
-            // An unanswered interrupt must not color the next turn's outcome.
-            this.interruptRequested = false;
-            throw error;
-        }
-    }
-    async respond(requestId, decision) {
-        this.state.requireOpen();
-        if (!this.pendingApprovals.has(requestId)) {
-            throw sessionStateError(CLAUDE.id, `no pending approval request "${requestId}"`);
-        }
-        const input = this.pendingApprovals.get(requestId);
-        this.pendingApprovals.delete(requestId);
-        const response = decision === APPROVAL_DECISION.accept
-            ? {
-                behavior: CLAUDE_SESSION.stream.behavior.allow,
-                updatedInput: input,
-            }
-            : {
-                behavior: CLAUDE_SESSION.stream.behavior.deny,
-                message: DECLINED_MESSAGE,
-            };
-        this.process.writeLine(JSON.stringify({
-            type: CLAUDE_SESSION.stream.type.controlResponse,
-            response: {
-                subtype: CLAUDE_SESSION.stream.subtype.success,
-                [CLAUDE_SESSION.stream.field.requestId]: requestId,
-                response,
-            },
-        }));
-    }
-    async close() {
-        await this.process.close();
-        await this.reading;
-    }
-    writeUserLine(text) {
-        this.process.writeLine(JSON.stringify({
-            type: CLAUDE_SESSION.stream.type.user,
-            message: { role: CLAUDE_SESSION.stream.type.user, content: text },
-        }));
-    }
-    awaitControlResponse(requestId) {
-        return new Promise((resolve, reject) => {
-            const cancelTimeout = this.ctx.clock.setTimeout(() => {
-                this.pendingControls.delete(requestId);
-                reject(new AgentError({
-                    code: AGENT_ERROR_CODE.timeout,
-                    classification: AgentError.agentFailure(AGENT_ERROR_CODE.timeout),
-                    message: "Claude did not answer the control request in time",
-                    data: {
-                        kind: TIMEOUT_KIND.total,
-                        limitMs: CONTROL_RESPONSE_TIMEOUT_MS,
-                    },
-                    agentId: CLAUDE.id,
-                }));
-            }, CONTROL_RESPONSE_TIMEOUT_MS);
-            this.pendingControls.set(requestId, { resolve, reject, cancelTimeout });
-        });
-    }
-    async read() {
-        try {
-            for await (const line of this.process.lines()) {
-                const record = readJsonRecord(line);
-                if (record !== null) {
-                    this.handleRecord(record, line);
-                }
-            }
-        }
-        catch (error) {
-            this.ctx.logger.log("error", "claude session reader failed", error);
-        }
-        finally {
-            // Whatever happened above, the stream must end so `events` consumers
-            // and `close()` are released.
-            const exit = await this.process.exit;
-            for (const pending of this.pendingControls.values()) {
-                pending.cancelTimeout();
-                pending.reject(sessionStateError(CLAUDE.id, "session process exited"));
-            }
-            this.pendingControls.clear();
-            this.pendingApprovals.clear();
-            this.interruptRequested = false;
-            this.state.end(exit, this.process.stderr);
-        }
-    }
-    handleRecord(record, line) {
-        const type = readString(record, CLAUDE_SESSION.stream.field.type);
-        if (type === CLAUDE_SESSION.stream.type.assistant) {
-            for (const event of parseClaudeLine(line)) {
-                if (event.type === AGENT_EVENT_TYPE.message) {
-                    this.state.message(event.text);
-                }
-                else if (event.type === AGENT_EVENT_TYPE.tool) {
-                    this.state.emit({ type: SESSION_EVENT_TYPE.tool, name: event.name });
-                }
-            }
-            return;
-        }
-        if (type === CLAUDE_SESSION.stream.type.result) {
-            this.handleResult(record);
-            return;
-        }
-        if (type === CLAUDE_SESSION.stream.type.controlRequest) {
-            this.handleControlRequest(record);
-            return;
-        }
-        if (type === CLAUDE_SESSION.stream.type.controlResponse) {
-            this.handleControlResponse(record);
-        }
-    }
-    handleResult(record) {
-        const isError = record[CLAUDE_SESSION.stream.field.isError] === true;
-        const outcome = this.interruptRequested
-            ? TURN_OUTCOME.interrupted
-            : isError
-                ? TURN_OUTCOME.failed
-                : TURN_OUTCOME.completed;
-        this.interruptRequested = false;
-        // Approval requests belong to the turn that raised them.
-        this.pendingApprovals.clear();
-        this.state.endTurn(outcome, readString(record, CLAUDE_SESSION.stream.field.result));
-    }
-    handleControlRequest(record) {
-        const requestId = readString(record, CLAUDE_SESSION.stream.field.requestId);
-        const request = readRecord(record, CLAUDE_SESSION.stream.field.request);
-        const subtype = request === null
-            ? null
-            : readString(request, CLAUDE_SESSION.stream.field.subtype);
-        if (requestId === null || request === null) {
-            return;
-        }
-        if (subtype !== CLAUDE_SESSION.stream.subtype.canUseTool) {
-            this.ctx.logger.log("warn", `ignoring unsupported claude control request "${subtype ?? "?"}"`);
-            return;
-        }
-        this.pendingApprovals.set(requestId, request[CLAUDE_SESSION.stream.field.input]);
-        const toolName = readString(request, CLAUDE_SESSION.stream.field.toolName) ?? "";
-        const description = readString(request, CLAUDE_SESSION.stream.field.description);
-        this.state.emit({
-            type: SESSION_EVENT_TYPE.approvalRequested,
-            requestId,
-            summary: description === null ? toolName : `${toolName} ${description}`,
-            decisions: CLAUDE_APPROVAL_DECISIONS,
-        });
-    }
-    handleControlResponse(record) {
-        const response = readRecord(record, CLAUDE_SESSION.stream.field.response);
-        const requestId = response === null
-            ? null
-            : readString(response, CLAUDE_SESSION.stream.field.requestId);
-        if (response === null || requestId === null) {
-            return;
-        }
-        const pending = this.pendingControls.get(requestId);
-        if (pending === undefined) {
-            return;
-        }
-        this.pendingControls.delete(requestId);
-        pending.cancelTimeout();
-        if (readString(response, CLAUDE_SESSION.stream.field.subtype) ===
-            CLAUDE_SESSION.stream.subtype.error) {
-            pending.reject(sessionStateError(CLAUDE.id, redactSecrets(readString(response, CLAUDE_SESSION.stream.field.error) ??
-                "control request failed")));
-            return;
-        }
-        pending.resolve();
-    }
-}
-async function openClaudeSession(target, options, ctx, sessionOptions) {
-    const process = await SessionProcess.spawn({
-        command: CLAUDE.command,
-        args: sessionArgs(options.permissions, target, sessionOptions),
-        cwd: options.workspace,
-        ctx,
-        agentId: CLAUDE.id,
-    });
-    return new ClaudeSession(target.sessionId, process, ctx);
-}
-function claudeRoot(ctx, ...segments) {
-    return path.join(ctx.location.homeDir, CLAUDE_SESSION.files.root, ...segments);
-}
-/** `~/.claude/projects/<encoded cwd>/<id>.jsonl` — the project directory name is not derivable, so scan. */
-async function findClaudeTranscript(ctx, id) {
-    const root = claudeRoot(ctx, CLAUDE_SESSION.files.projects);
-    for (const project of await readDirectoryNames(root)) {
-        const candidate = path.join(root, project, `${id}${CLAUDE_SESSION.files.transcriptExtension}`);
-        if (await fileExists(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-/** `~/.claude/sessions/<pid>.json` — one file per live CLI process, keyed by pid. */
-async function claudeRegistryOwner(ctx, id) {
-    const root = claudeRoot(ctx, CLAUDE_SESSION.files.sessions);
-    for (const name of await readDirectoryNames(root)) {
-        if (!name.endsWith(CLAUDE_SESSION.files.registryExtension)) {
-            continue;
-        }
-        const entry = await readJsonFile(path.join(root, name));
-        if (entry === null ||
-            readString(entry, CLAUDE_SESSION.files.sessionId) !== id) {
-            continue;
-        }
-        return {
-            kind: SESSION_OWNER_KIND.process,
-            pid: readNumber(entry, CLAUDE_SESSION.files.pid),
-            entrypoint: readString(entry, CLAUDE_SESSION.files.entrypoint),
-        };
-    }
-    return { kind: SESSION_OWNER_KIND.none };
-}
-function permissionModeFrom(value) {
-    return value !== null &&
-        Object.values(CLAUDE_PERMISSION_MODE).includes(value)
-        ? value
-        : null;
-}
-async function inspectClaudeSession(id, ctx) {
-    assertHostSessionId(id, CLAUDE.id);
-    const transcript = await findClaudeTranscript(ctx, id);
-    if (transcript === null) {
-        return null;
-    }
-    const cwd = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE_SESSION.files.cwd));
-    if (cwd.first === null) {
-        return null;
-    }
-    const modes = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE_SESSION.files.permissionMode));
-    const mode = permissionModeFrom(modes.last);
-    return {
-        workspace: cwd.first,
-        lastPermissions: mode === null ? null : { mode },
-        owner: await claudeRegistryOwner(ctx, id),
-        archived: false,
-    };
-}
-export function claudeSessions(options) {
-    return {
-        open: (resolved, ctx) => openClaudeSession({ kind: "new", sessionId: randomUUID() }, resolved, ctx, options),
-        resume: async (id, resolved, ctx) => {
-            assertHostSessionId(id, CLAUDE.id);
-            return openClaudeSession({ kind: "resume", sessionId: id }, resolved, ctx, options);
-        },
-        inspect: inspectClaudeSession,
-    };
-}

package/dist/agents/claude-stream.d.ts

@@ -1,65 +0,0 @@
-/**
- * Claude CLI stream-json vocabulary and line readers, shared by the
- * one-shot run adapter (`claude.ts`) and the long-lived session adapter
- * (`claude-session.ts`): one place spells the CLI's flags and the NDJSON
- * field names both of them read.
- */
-import type { AgentEvent } from "../core/run.js";
-import type { CliResultCapture } from "../kernel/cli-agent.js";
-export declare const CLAUDE: {
-    readonly id: "claude";
-    readonly command: "claude";
-    readonly cli: {
-        readonly prompt: "-p";
-        readonly model: "--model";
-        readonly effort: "--effort";
-        readonly outputFormat: "--output-format";
-        readonly streamJson: "stream-json";
-        readonly permissionMode: "--permission-mode";
-        readonly bypassPermissions: "bypassPermissions";
-        readonly defaultPermissionMode: "default";
-        readonly verbose: "--verbose";
-        readonly tools: "--tools";
-        readonly allowedTools: "--allowedTools";
-        readonly safeMode: "--safe-mode";
-        readonly strictMcpConfig: "--strict-mcp-config";
-        readonly noSessionPersistence: "--no-session-persistence";
-    };
-    readonly auth: {
-        readonly statusArgs: readonly ["auth", "status", "--json"];
-        readonly loginArgs: readonly ["auth", "login", "--claudeai"];
-    };
-    readonly mcp: {
-        readonly addJson: "add-json";
-        readonly mcp: "mcp";
-        readonly remove: "remove";
-        readonly scope: "--scope";
-    };
-    readonly plugin: {
-        readonly plugin: "plugin";
-        readonly install: "install";
-    };
-    readonly json: {
-        readonly field: {
-            readonly type: "type";
-            readonly message: "message";
-            readonly content: "content";
-            readonly text: "text";
-            readonly name: "name";
-            readonly usage: "usage";
-            readonly result: "result";
-            readonly inputTokens: "input_tokens";
-            readonly outputTokens: "output_tokens";
-            readonly totalCost: "total_cost_usd";
-        };
-        readonly type: {
-            readonly assistant: "assistant";
-            readonly result: "result";
-            readonly text: "text";
-            readonly toolUse: "tool_use";
-        };
-    };
-};
-export declare function parseClaudeLine(line: string): AgentEvent[];
-export declare function parseClaudeResult(line: string): CliResultCapture | null;
-//# sourceMappingURL=claude-stream.d.ts.map

package/dist/agents/claude-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-stream.d.ts","sourceRoot":"","sources":["../../src/agents/claude-stream.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,gBAAgB,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDT,CAAC;AAEX,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAkC1D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAkBvE"}

package/dist/agents/claude.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/agents/claude.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA4CH,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,qBAAqB,CAAC;AAG7B,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAwD1D;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,cAAc,CA0CvD;AA6TD,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;CAClD,CAAC;AAEF,wBAAgB,MAAM,CACpB,OAAO,GAAE,aAAkB,GAC1B,eAAe,CAAC,QAAQ,EAAE,wBAAwB,CAAC,CAiFrD"}

package/dist/agents/codex-session.d.ts

@@ -1,52 +0,0 @@
-/**
- * Codex session adapter: one `codex app-server` process holding one thread.
- *
- * Protocol facts (codex 0.153.4, T53 / T57 / T61 lab runs):
- * - `thread/start {cwd, sandbox, approvalPolicy, approvalsReviewer}` creates
- *   the thread and takes its writer lock; with a writable sandbox Codex also
- *   appends a `trust_level` entry for `cwd` to `~/.codex/config.toml`;
- * - `thread/resume` must repeat the permissions — without `sandbox` the
- *   resumed turns ran as danger-full-access; it answers -32600 "already has
- *   an active writer" while another process holds the thread and -32600
- *   "… is archived" for an archived one (`thread/unarchive` first, opt-in);
- * - `turn/start` answers the turn id at once; `turn/steer {expectedTurnId}`
- *   appends to it; `turn/interrupt` ends it with `turn/completed`
- *   status `interrupted` (the command's own `item/completed` may trail by ~36 s);
- * - `item/commandExecution/requestApproval` is a server request answered by
- *   `{"decision": "accept" | "decline"}`; closing stdin releases the lock.
- */
-import { CODEX_SANDBOX_MODE } from "../codex/protocol.js";
-export type { CodexSandboxMode } from "../codex/protocol.js";
-import { type SessionCapability } from "../kernel/session.js";
-/** `approval_policy` words (codex 0.153.4 `AskForApproval`; the granular object form is not modeled). */
-export declare const CODEX_APPROVAL_POLICY: {
-    readonly untrusted: "untrusted";
-    readonly onRequest: "on-request";
-    readonly never: "never";
-};
-export type CodexApprovalPolicy = (typeof CODEX_APPROVAL_POLICY)[keyof typeof CODEX_APPROVAL_POLICY];
-export declare const CODEX_APPROVALS_REVIEWER: {
-    readonly user: "user";
-    readonly autoReview: "auto_review";
-    readonly guardianSubagent: "guardian_subagent";
-};
-export type CodexApprovalsReviewer = (typeof CODEX_APPROVALS_REVIEWER)[keyof typeof CODEX_APPROVALS_REVIEWER];
-/** Spelled as the rollout's `turn_context.sandbox_policy` records it. */
-export type CodexSandboxPolicy = {
-    readonly type: typeof CODEX_SANDBOX_MODE.readOnly;
-} | {
-    readonly type: typeof CODEX_SANDBOX_MODE.dangerFullAccess;
-} | {
-    readonly type: typeof CODEX_SANDBOX_MODE.workspaceWrite;
-    readonly writableRoots: readonly string[];
-    readonly networkAccess: boolean;
-    readonly excludeTmpdirEnvVar: boolean;
-    readonly excludeSlashTmp: boolean;
-};
-export type CodexSessionPermissions = {
-    readonly approvalPolicy: CodexApprovalPolicy;
-    readonly approvalsReviewer: CodexApprovalsReviewer;
-    readonly sandbox: CodexSandboxPolicy;
-};
-export declare function codexSessions(): SessionCapability<CodexSessionPermissions>;
-//# sourceMappingURL=codex-session.d.ts.map

package/dist/agents/codex-session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codex-session.d.ts","sourceRoot":"","sources":["../../src/agents/codex-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,EAGL,kBAAkB,EAGnB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AA2B7D,OAAO,EAIL,KAAK,iBAAiB,EAIvB,MAAM,sBAAsB,CAAC;AAK9B,yGAAyG;AACzG,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,yEAAyE;AACzE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,QAAQ,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,gBAAgB,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,cAAc,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEN,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,sBAAsB,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC,CAAC;AAkkBF,wBAAgB,aAAa,IAAI,iBAAiB,CAAC,uBAAuB,CAAC,CAM1E"}