@oka-core/reason 0.2.0

package/dist/client.js

@@ -0,0 +1,292 @@
+import { EventBuffer } from "./buffer.js";
+import { resolveApiKey, resolveApiKeyWithRefresh } from "./auth.js";
+/**
+ * Unified HTTP client for Oka Reason API.
+ *
+ * Merges the functionality of OkaClient + OkaContextClient + OkaClientExt
+ * into a single class with all capabilities:
+ * - ingest() — fire-and-forget event ingestion with buffering
+ * - getContext() — the flagship context query (ranked learnings by topic)
+ * - getLearnings() — enhanced learning queries
+ * - getLearningStats() — aggregate statistics
+ * - queryEvents() — raw event queries
+ * - getBacklog() — backlog item listing
+ * - triggerConsolidation() — manual consolidation trigger
+ */
+export class OkaClient {
+    apiUrl;
+    apiKey;
+    repo;
+    buffer;
+    agentId;
+    sessionId;
+    timeout;
+    constructor(config) {
+        this.apiUrl = (config?.apiUrl ||
+            process.env["OKA_API_URL"] ||
+            "http://localhost:3001").replace(/\/$/, "");
+        this.apiKey = config?.apiKey || "";
+        this.repo = config?.repo || process.env["OKA_REPO"] || "unknown";
+        this.agentId = process.env["AGENT_ID"] || `agent-${process.pid}`;
+        this.sessionId = process.env["SESSION_ID"] || `session-${Date.now()}`;
+        this.buffer = new EventBuffer(100);
+        this.timeout = 15_000;
+    }
+    updateApiKey(key) {
+        this.apiKey = key;
+    }
+    // ─── Write operations ───────────────────────────────────────────
+    async ingest(event) {
+        const full = {
+            ...event,
+            repo: this.repo,
+            agent_id: this.agentId,
+            session_id: this.sessionId,
+            timestamp: new Date().toISOString(),
+        };
+        this.buffer.add(full);
+        await this.flush();
+    }
+    async flush() {
+        const events = this.buffer.drain();
+        if (events.length === 0)
+            return;
+        try {
+            await fetch(`${this.apiUrl}/api/reasoning/ingest`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.authHeaders(),
+                },
+                body: JSON.stringify({ events }),
+                signal: AbortSignal.timeout(5_000),
+            });
+        }
+        catch {
+            // Re-buffer failed events (up to capacity)
+            for (const e of events)
+                this.buffer.add(e);
+        }
+    }
+    // ─── Context query (the differentiator) ─────────────────────────
+    /**
+     * Get ranked learnings relevant to a topic.
+     * Calls `GET /api/learnings/context/:topic`.
+     */
+    async getContext(topic, options) {
+        const params = new URLSearchParams({ repo: this.repo });
+        if (options?.file_patterns)
+            params.set("file_patterns", options.file_patterns);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.min_confidence)
+            params.set("min_confidence", String(options.min_confidence));
+        if (options?.include_events)
+            params.set("include_events", String(options.include_events));
+        if (options?.visibility)
+            params.set("visibility", options.visibility);
+        return this.get(`/api/learnings/context/${encodeURIComponent(topic)}?${params}`).catch(() => ({ topic, learnings: [], total_matched: 0 }));
+    }
+    // ─── Event queries ──────────────────────────────────────────────
+    async query(params) {
+        try {
+            const url = new URL(`${this.apiUrl}/api/reasoning/query`);
+            url.searchParams.set("repo", this.repo);
+            for (const [k, v] of Object.entries(params)) {
+                if (v)
+                    url.searchParams.set(k, v);
+            }
+            const res = await fetch(url.toString(), {
+                headers: this.authHeaders(),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!res.ok)
+                return { results: [], confidence: 0, source_count: 0 };
+            return (await res.json());
+        }
+        catch {
+            return { results: [], confidence: 0, source_count: 0 };
+        }
+    }
+    // ─── Learning queries ───────────────────────────────────────────
+    /**
+     * Query enhanced learnings with rich filtering.
+     * GET /api/reasoning/learnings/enhanced
+     */
+    async getLearnings(params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set("repo", params?.repo ?? this.repo);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (key !== "repo" && value !== undefined && value !== null) {
+                    searchParams.set(key, String(value));
+                }
+            }
+        }
+        return this.get(`/api/reasoning/learnings/enhanced?${searchParams}`).catch(() => ({ learnings: [], total: 0, limit: 50, offset: 0 }));
+    }
+    /**
+     * Get learning statistics.
+     * GET /api/reasoning/learnings/stats
+     */
+    async getLearningStats(repo) {
+        const r = repo ?? this.repo;
+        return this.get(`/api/reasoning/learnings/stats?repo=${r}`).catch(() => ({
+            total_learnings: 0,
+            by_category: {},
+            by_status: {},
+            avg_confidence: 0,
+            high_confidence_count: 0,
+            source_type_distribution: {},
+        }));
+    }
+    // ─── Backlog queries ────────────────────────────────────────────
+    /**
+     * Query backlog items.
+     * GET /api/reasoning/backlog
+     */
+    async getBacklog(params) {
+        const searchParams = new URLSearchParams();
+        searchParams.set("repo", params?.repo ?? this.repo);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (key !== "repo" && value !== undefined && value !== null) {
+                    searchParams.set(key, String(value));
+                }
+            }
+        }
+        return this.get(`/api/reasoning/backlog?${searchParams}`).catch(() => []);
+    }
+    // ─── Semantic search ────────────────────────────────────────────
+    /**
+     * Semantic search for learnings by natural language query.
+     * GET /api/learnings/semantic/:query
+     */
+    async semanticSearch(query, options) {
+        const params = new URLSearchParams();
+        // repo is optional for account_wide visibility (cross-repo search)
+        if (options?.repo)
+            params.set("repo", options.repo);
+        else if (!options?.visibility ||
+            options.visibility === "user_repo" ||
+            options.visibility === "user_private")
+            params.set("repo", this.repo);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.min_similarity)
+            params.set("min_similarity", String(options.min_similarity));
+        if (options?.min_confidence)
+            params.set("min_confidence", String(options.min_confidence));
+        if (options?.visibility)
+            params.set("visibility", options.visibility);
+        return this.get(`/api/learnings/semantic/${encodeURIComponent(query)}?${params}`).catch(() => ({ query, results: [], total: 0 }));
+    }
+    // ─── Consolidation ──────────────────────────────────────────────
+    /**
+     * Trigger a consolidation run.
+     * POST /api/reasoning/consolidate
+     */
+    async triggerConsolidation(req) {
+        return this.post("/api/reasoning/consolidate", req);
+    }
+    // ─── HTTP helpers ───────────────────────────────────────────────
+    authHeaders() {
+        // Resolve credentials fresh each call so .env / credentials.json
+        // changes (e.g. after `login`) are picked up without MCP restart.
+        const key = this.apiKey || resolveApiKey();
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (key) {
+            // JWTs have dots (header.payload.signature); API keys don't.
+            // Sending both headers causes the server to try Bearer first and fail
+            // when the value is an API key, never falling back to X-Api-Key.
+            const isJwt = key.includes(".");
+            if (isJwt) {
+                headers["Authorization"] = `Bearer ${key}`;
+            }
+            else {
+                headers["X-Api-Key"] = key;
+            }
+        }
+        return headers;
+    }
+    async get(path) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.apiUrl}${path}`, {
+                method: "GET",
+                headers: this.authHeaders(),
+                signal: controller.signal,
+            });
+            if (response.status === 401) {
+                const retried = await this.retryWithRefresh("GET", path);
+                if (retried !== null)
+                    return retried;
+            }
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            return response.json();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async post(path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.apiUrl}${path}`, {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (response.status === 401) {
+                const retried = await this.retryWithRefresh("POST", path, body);
+                if (retried !== null)
+                    return retried;
+            }
+            if (!response.ok) {
+                const text = await response.text().catch(() => "");
+                throw new Error(`HTTP ${response.status}: ${text}`);
+            }
+            return response.json();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * On 401, attempt to refresh the token and retry the request once.
+     * Returns the parsed JSON response on success, or null if refresh failed.
+     */
+    async retryWithRefresh(method, path, body) {
+        const newKey = await resolveApiKeyWithRefresh();
+        if (!newKey)
+            return null;
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        const isJwt = newKey.includes(".");
+        if (isJwt) {
+            headers["Authorization"] = `Bearer ${newKey}`;
+        }
+        else {
+            headers["X-Api-Key"] = newKey;
+        }
+        const opts = {
+            method,
+            headers,
+            signal: AbortSignal.timeout(this.timeout),
+        };
+        if (body !== undefined) {
+            opts.body = JSON.stringify(body);
+        }
+        const retryResponse = await fetch(`${this.apiUrl}${path}`, opts);
+        if (!retryResponse.ok)
+            return null;
+        return retryResponse.json();
+    }
+}

package/dist/client_ext.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @deprecated Use `OkaClient` from `./client.js` instead.
+ * This module is kept for backward compatibility.
+ * The unified OkaClient now includes all consolidation engine methods.
+ */
+export type { ConsolidateRequest, ConsolidateResponse, EnhancedLearningParams, PaginatedLearnings, BacklogParams, LearningStats, } from "./client.js";
+import { OkaClient } from "./client.js";
+/**
+ * @deprecated Use `OkaClient` directly. `OkaClientExt` is now a type alias.
+ */
+export declare class OkaClientExt extends OkaClient {
+}
+//# sourceMappingURL=client_ext.d.ts.map

package/dist/client_ext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_ext.d.ts","sourceRoot":"","sources":["../src/client_ext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,EACb,aAAa,GACd,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;GAEG;AACH,qBAAa,YAAa,SAAQ,SAAS;CAAG"}

package/dist/client_ext.js

@@ -0,0 +1,12 @@
+/**
+ * @deprecated Use `OkaClient` from `./client.js` instead.
+ * This module is kept for backward compatibility.
+ * The unified OkaClient now includes all consolidation engine methods.
+ */
+// Re-export the unified client as OkaClientExt for backward compat
+import { OkaClient } from "./client.js";
+/**
+ * @deprecated Use `OkaClient` directly. `OkaClientExt` is now a type alias.
+ */
+export class OkaClientExt extends OkaClient {
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { OkaClient } from "./client.js";
+import { registerWriteTools } from "./tools/write.js";
+import { registerReadTools } from "./tools/read.js";
+import { registerAuthTools } from "./tools/auth.js";
+import { loadEnvFile } from "./auth.js";
+// Load .env from the project root (cwd), env vars take precedence
+loadEnvFile(process.cwd());
+const server = new McpServer({
+    name: "@oka-core/reason",
+    version: "0.3.0",
+});
+// Client resolves credentials lazily on each request — no restart needed
+// after login or credential changes.
+const client = new OkaClient();
+registerWriteTools(server, client);
+registerReadTools(server, client);
+registerAuthTools(server, client);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/schemas.d.ts

@@ -0,0 +1,225 @@
+import { z } from "zod";
+export declare const RecordDecisionInput: z.ZodObject<{
+    description: z.ZodString;
+    rationale: z.ZodString;
+    alternatives_considered: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    description: string;
+    rationale: string;
+    alternatives_considered: string[];
+}, {
+    confidence: number;
+    description: string;
+    rationale: string;
+    alternatives_considered?: string[] | undefined;
+}>;
+export type RecordDecisionInput = z.infer<typeof RecordDecisionInput>;
+export declare const RecordExplorationInput: z.ZodObject<{
+    area: z.ZodString;
+    findings: z.ZodString;
+    relevance_score: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    area: string;
+    findings: string;
+    relevance_score: number;
+}, {
+    area: string;
+    findings: string;
+    relevance_score: number;
+}>;
+export type RecordExplorationInput = z.infer<typeof RecordExplorationInput>;
+export declare const RecordDeviationInput: z.ZodObject<{
+    planned_action: z.ZodString;
+    actual_action: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    planned_action: string;
+    actual_action: string;
+    reason: string;
+}, {
+    planned_action: string;
+    actual_action: string;
+    reason: string;
+}>;
+export type RecordDeviationInput = z.infer<typeof RecordDeviationInput>;
+export declare const RecordCompletionInput: z.ZodObject<{
+    task_id: z.ZodString;
+    outcome: z.ZodEnum<["success", "partial", "failed"]>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    quality_signals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    task_id: string;
+    outcome: "success" | "partial" | "failed";
+    artifacts: string[];
+    quality_signals: Record<string, number>;
+}, {
+    task_id: string;
+    outcome: "success" | "partial" | "failed";
+    artifacts?: string[] | undefined;
+    quality_signals?: Record<string, number> | undefined;
+}>;
+export type RecordCompletionInput = z.infer<typeof RecordCompletionInput>;
+export declare const RecordObservationInput: z.ZodObject<{
+    category: z.ZodEnum<["architecture", "bug_pattern", "convention", "performance", "security", "workflow", "dependency", "code_quality", "other"]>;
+    summary: z.ZodString;
+    details: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    file_patterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    file_patterns: string[];
+    confidence: number;
+    category: "architecture" | "bug_pattern" | "convention" | "performance" | "security" | "workflow" | "dependency" | "code_quality" | "other";
+    tags: string[];
+    summary: string;
+    details?: string | undefined;
+}, {
+    category: "architecture" | "bug_pattern" | "convention" | "performance" | "security" | "workflow" | "dependency" | "code_quality" | "other";
+    summary: string;
+    file_patterns?: string[] | undefined;
+    confidence?: number | undefined;
+    tags?: string[] | undefined;
+    details?: string | undefined;
+}>;
+export type RecordObservationInput = z.infer<typeof RecordObservationInput>;
+export declare const GetContextInput: z.ZodObject<{
+    topic: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    file_patterns: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    min_confidence: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    min_confidence: number;
+    topic: string;
+    repo?: string | undefined;
+    file_patterns?: string | undefined;
+}, {
+    topic: string;
+    repo?: string | undefined;
+    file_patterns?: string | undefined;
+    limit?: number | undefined;
+    min_confidence?: number | undefined;
+}>;
+export type GetContextInput = z.infer<typeof GetContextInput>;
+export declare const ListLearningsInput: z.ZodObject<{
+    repo: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodEnum<["architecture", "bug_pattern", "convention", "decision", "performance", "security", "workflow", "domain_knowledge"]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "reinforced", "contradicted", "obsolete"]>>;
+    min_confidence: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    repo?: string | undefined;
+    min_confidence?: number | undefined;
+    category?: "decision" | "architecture" | "bug_pattern" | "convention" | "performance" | "security" | "workflow" | "domain_knowledge" | undefined;
+    status?: "active" | "reinforced" | "contradicted" | "obsolete" | undefined;
+}, {
+    repo?: string | undefined;
+    limit?: number | undefined;
+    min_confidence?: number | undefined;
+    category?: "decision" | "architecture" | "bug_pattern" | "convention" | "performance" | "security" | "workflow" | "domain_knowledge" | undefined;
+    status?: "active" | "reinforced" | "contradicted" | "obsolete" | undefined;
+}>;
+export type ListLearningsInput = z.infer<typeof ListLearningsInput>;
+export declare const GetDecisionsInput: z.ZodObject<{
+    repo: z.ZodString;
+    module: z.ZodOptional<z.ZodString>;
+    timeframe: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    module?: string | undefined;
+    timeframe?: string | undefined;
+}, {
+    repo: string;
+    module?: string | undefined;
+    timeframe?: string | undefined;
+}>;
+export type GetDecisionsInput = z.infer<typeof GetDecisionsInput>;
+export declare const GetPatternsInput: z.ZodObject<{
+    repo: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+}, {
+    repo: string;
+}>;
+export type GetPatternsInput = z.infer<typeof GetPatternsInput>;
+export declare const SuggestPrioritiesInput: z.ZodObject<{
+    repo: z.ZodString;
+    backlog: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    backlog: string[];
+}, {
+    repo: string;
+    backlog: string[];
+}>;
+export type SuggestPrioritiesInput = z.infer<typeof SuggestPrioritiesInput>;
+export declare const ReasoningEvent: z.ZodObject<{
+    id: z.ZodString;
+    repo: z.ZodString;
+    agent_id: z.ZodString;
+    event_type: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    session_id: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    id: string;
+    agent_id: string;
+    event_type: string;
+    payload: Record<string, unknown>;
+    session_id: string;
+    timestamp: string;
+}, {
+    repo: string;
+    id: string;
+    agent_id: string;
+    event_type: string;
+    payload: Record<string, unknown>;
+    session_id: string;
+    timestamp: string;
+}>;
+export type ReasoningEvent = z.infer<typeof ReasoningEvent>;
+export declare const Learning: z.ZodObject<{
+    id: z.ZodString;
+    repo: z.ZodString;
+    summary: z.ZodString;
+    file_patterns: z.ZodArray<z.ZodString, "many">;
+    tags: z.ZodArray<z.ZodString, "many">;
+    confidence: z.ZodNumber;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    file_patterns: string[];
+    confidence: number;
+    tags: string[];
+    summary: string;
+    id: string;
+    created_at: string;
+}, {
+    repo: string;
+    file_patterns: string[];
+    confidence: number;
+    tags: string[];
+    summary: string;
+    id: string;
+    created_at: string;
+}>;
+export type Learning = z.infer<typeof Learning>;
+export declare const QueryResult: <T extends z.ZodType>(itemSchema: T) => z.ZodObject<{
+    results: z.ZodArray<T, "many">;
+    confidence: z.ZodNumber;
+    source_count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    source_count: number;
+    results: T["_output"][];
+}, {
+    confidence: number;
+    source_count: number;
+    results: T["_input"][];
+}>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EAiBjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAI5E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAM1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAmB7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAI5E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAQzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAQnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC;;;;;;;;;;;;EAK1D,CAAC"}