opencode-swarm-plugin 0.22.0 → 0.23.0

package/dist/swarm.d.ts

@@ -0,0 +1,455 @@
+/**
+ * Swarm Module - High-level swarm coordination
+ *
+ * This module re-exports from focused submodules for backward compatibility.
+ * For new code, prefer importing from specific modules:
+ * - swarm-strategies.ts - Strategy selection
+ * - swarm-decompose.ts - Task decomposition
+ * - swarm-prompts.ts - Prompt templates
+ * - swarm-orchestrate.ts - Status and completion
+ *
+ * @module swarm
+ */
+export * from "./swarm-strategies";
+export * from "./swarm-decompose";
+export * from "./swarm-prompts";
+export * from "./swarm-orchestrate";
+/**
+ * Combined swarm tools for plugin registration.
+ * Includes all tools from strategy, decompose, prompt, and orchestrate modules.
+ */
+export declare const swarmTools: {
+    swarm_init: {
+        description: string;
+        args: {
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            project_path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_status: {
+        description: string;
+        args: {
+            epic_id: import("zod").ZodString;
+            project_key: import("zod").ZodString;
+        };
+        execute(args: {
+            epic_id: string;
+            project_key: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_progress: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            status: import("zod").ZodEnum<{
+                in_progress: "in_progress";
+                blocked: "blocked";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            progress_percent: import("zod").ZodOptional<import("zod").ZodNumber>;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            status: "in_progress" | "blocked" | "failed" | "completed";
+            message?: string | undefined;
+            progress_percent?: number | undefined;
+            files_touched?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_broadcast: {
+        description: string;
+        args: {
+            project_path: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            message: import("zod").ZodString;
+            importance: import("zod").ZodDefault<import("zod").ZodEnum<{
+                info: "info";
+                warning: "warning";
+                blocker: "blocker";
+            }>>;
+            files_affected: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            project_path: string;
+            agent_name: string;
+            epic_id: string;
+            message: string;
+            importance: "info" | "warning" | "blocker";
+            files_affected?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_complete: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            summary: import("zod").ZodString;
+            evaluation: import("zod").ZodOptional<import("zod").ZodString>;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            skip_ubs_scan: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            skip_verification: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            planned_files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            start_time: import("zod").ZodOptional<import("zod").ZodNumber>;
+            error_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            retry_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            summary: string;
+            evaluation?: string | undefined;
+            files_touched?: string[] | undefined;
+            skip_ubs_scan?: boolean | undefined;
+            skip_verification?: boolean | undefined;
+            planned_files?: string[] | undefined;
+            start_time?: number | undefined;
+            error_count?: number | undefined;
+            retry_count?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_record_outcome: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            duration_ms: import("zod").ZodNumber;
+            error_count: import("zod").ZodDefault<import("zod").ZodNumber>;
+            retry_count: import("zod").ZodDefault<import("zod").ZodNumber>;
+            success: import("zod").ZodBoolean;
+            files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            criteria: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                "research-based": "research-based";
+            }>>;
+            failure_mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                timeout: "timeout";
+                unknown: "unknown";
+                conflict: "conflict";
+                validation: "validation";
+                tool_failure: "tool_failure";
+                context_overflow: "context_overflow";
+                dependency_blocked: "dependency_blocked";
+                user_cancelled: "user_cancelled";
+            }>>;
+            failure_details: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            duration_ms: number;
+            error_count: number;
+            retry_count: number;
+            success: boolean;
+            files_touched?: string[] | undefined;
+            criteria?: string[] | undefined;
+            strategy?: "file-based" | "feature-based" | "risk-based" | "research-based" | undefined;
+            failure_mode?: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure" | "context_overflow" | "dependency_blocked" | "user_cancelled" | undefined;
+            failure_details?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_accumulate_error: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            error_type: import("zod").ZodEnum<{
+                timeout: "timeout";
+                unknown: "unknown";
+                conflict: "conflict";
+                validation: "validation";
+                tool_failure: "tool_failure";
+            }>;
+            message: import("zod").ZodString;
+            stack_trace: import("zod").ZodOptional<import("zod").ZodString>;
+            tool_name: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            error_type: "timeout" | "unknown" | "conflict" | "validation" | "tool_failure";
+            message: string;
+            stack_trace?: string | undefined;
+            tool_name?: string | undefined;
+            context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_get_error_context: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            include_resolved: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            bead_id: string;
+            include_resolved?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_resolve_error: {
+        description: string;
+        args: {
+            error_id: import("zod").ZodString;
+        };
+        execute(args: {
+            error_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_check_strikes: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            action: import("zod").ZodEnum<{
+                check: "check";
+                add_strike: "add_strike";
+                clear: "clear";
+                get_prompt: "get_prompt";
+            }>;
+            attempt: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            action: "check" | "add_strike" | "clear" | "get_prompt";
+            attempt?: string | undefined;
+            reason?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_checkpoint: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            files_modified: import("zod").ZodArray<import("zod").ZodString>;
+            progress_percent: import("zod").ZodNumber;
+            directives: import("zod").ZodOptional<import("zod").ZodObject<{
+                shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+                skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            error_context: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            project_key: string;
+            agent_name: string;
+            bead_id: string;
+            epic_id: string;
+            files_modified: string[];
+            progress_percent: number;
+            directives?: {
+                shared_context?: string | undefined;
+                skills_to_load?: string[] | undefined;
+                coordinator_notes?: string | undefined;
+            } | undefined;
+            error_context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_recover: {
+        description: string;
+        args: {
+            project_key: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+        };
+        execute(args: {
+            project_key: string;
+            epic_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_learn: {
+        description: string;
+        args: {
+            summary: import("zod").ZodString;
+            pattern_type: import("zod").ZodEnum<{
+                "code-pattern": "code-pattern";
+                "best-practice": "best-practice";
+                gotcha: "gotcha";
+                "tool-usage": "tool-usage";
+                "domain-knowledge": "domain-knowledge";
+                workflow: "workflow";
+            }>;
+            details: import("zod").ZodString;
+            example: import("zod").ZodOptional<import("zod").ZodString>;
+            when_to_use: import("zod").ZodString;
+            files_context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            create_skill: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            skill_name: import("zod").ZodOptional<import("zod").ZodString>;
+            skill_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            summary: string;
+            pattern_type: "code-pattern" | "best-practice" | "gotcha" | "tool-usage" | "domain-knowledge" | "workflow";
+            details: string;
+            when_to_use: string;
+            example?: string | undefined;
+            files_context?: string[] | undefined;
+            create_skill?: boolean | undefined;
+            skill_name?: string | undefined;
+            skill_tags?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_subtask_prompt: {
+        description: string;
+        args: {
+            agent_name: import("zod").ZodString;
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            subtask_description: import("zod").ZodOptional<import("zod").ZodString>;
+            files: import("zod").ZodArray<import("zod").ZodString>;
+            shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            agent_name: string;
+            bead_id: string;
+            epic_id: string;
+            subtask_title: string;
+            files: string[];
+            subtask_description?: string | undefined;
+            shared_context?: string | undefined;
+            project_path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_spawn_subtask: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            epic_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            subtask_description: import("zod").ZodOptional<import("zod").ZodString>;
+            files: import("zod").ZodArray<import("zod").ZodString>;
+            shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+            project_path: import("zod").ZodOptional<import("zod").ZodString>;
+            recovery_context: import("zod").ZodOptional<import("zod").ZodObject<{
+                shared_context: import("zod").ZodOptional<import("zod").ZodString>;
+                skills_to_load: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                coordinator_notes: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        };
+        execute(args: {
+            bead_id: string;
+            epic_id: string;
+            subtask_title: string;
+            files: string[];
+            subtask_description?: string | undefined;
+            shared_context?: string | undefined;
+            project_path?: string | undefined;
+            recovery_context?: {
+                shared_context?: string | undefined;
+                skills_to_load?: string[] | undefined;
+                coordinator_notes?: string | undefined;
+            } | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_evaluation_prompt: {
+        description: string;
+        args: {
+            bead_id: import("zod").ZodString;
+            subtask_title: import("zod").ZodString;
+            files_touched: import("zod").ZodArray<import("zod").ZodString>;
+        };
+        execute(args: {
+            bead_id: string;
+            subtask_title: string;
+            files_touched: string[];
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_plan_prompt: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            strategy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                auto: "auto";
+            }>>;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            include_skills: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            context?: string | undefined;
+            query_cass?: boolean | undefined;
+            cass_limit?: number | undefined;
+            include_skills?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_decompose: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodNumber>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            query_cass: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            cass_limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            context?: string | undefined;
+            query_cass?: boolean | undefined;
+            cass_limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_validate_decomposition: {
+        description: string;
+        args: {
+            response: import("zod").ZodString;
+        };
+        execute(args: {
+            response: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_delegate_planning: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            max_subtasks: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+            strategy: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                auto: "auto";
+            }>>>;
+            query_cass: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        };
+        execute(args: {
+            task: string;
+            max_subtasks: number;
+            strategy: "file-based" | "feature-based" | "risk-based" | "auto";
+            query_cass: boolean;
+            context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    swarm_select_strategy: {
+        description: string;
+        args: {
+            task: import("zod").ZodString;
+            codebase_context: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            task: string;
+            codebase_context?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=swarm.d.ts.map

package/dist/swarm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAQpC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAC"}

package/dist/tool-availability.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tool Availability Module
+ *
+ * Checks for external tool availability and provides graceful degradation.
+ * Tools are checked once and cached for the session.
+ *
+ * Supported tools:
+ * - semantic-memory: Learning persistence with semantic search
+ * - cass: Cross-agent session search for historical context
+ * - ubs: Universal bug scanner for pre-commit checks
+ * - beads (bd): Git-backed issue tracking
+ * - swarm-mail: Embedded multi-agent coordination (PGLite-based)
+ * - agent-mail: DEPRECATED - Legacy MCP server (use swarm-mail instead)
+ */
+export type ToolName = "semantic-memory" | "cass" | "ubs" | "beads" | "swarm-mail" | "agent-mail";
+export interface ToolStatus {
+    available: boolean;
+    checkedAt: string;
+    error?: string;
+    version?: string;
+}
+export interface ToolAvailability {
+    tool: ToolName;
+    status: ToolStatus;
+    fallbackBehavior: string;
+}
+/**
+ * Check if a tool is available (cached)
+ *
+ * @param tool - Tool name to check
+ * @returns Tool status
+ */
+export declare function checkTool(tool: ToolName): Promise<ToolStatus>;
+/**
+ * Check if a tool is available (simple boolean, cached)
+ */
+export declare function isToolAvailable(tool: ToolName): Promise<boolean>;
+/**
+ * Get full availability info including fallback behavior
+ */
+export declare function getToolAvailability(tool: ToolName): Promise<ToolAvailability>;
+/**
+ * Check all tools and return availability map
+ */
+export declare function checkAllTools(): Promise<Map<ToolName, ToolAvailability>>;
+/**
+ * Log a warning when a tool is missing.
+ * Uses Set to deduplicate - logs once per tool per session to prevent spam
+ * when tool availability is checked repeatedly.
+ */
+export declare function warnMissingTool(tool: ToolName): void;
+/**
+ * Require a tool - throws if not available
+ *
+ * Use this for tools that are mandatory for a feature.
+ */
+export declare function requireTool(tool: ToolName): Promise<void>;
+/**
+ * Execute with fallback - runs the action if tool available, otherwise runs fallback
+ *
+ * @param tool - Tool to check
+ * @param action - Action to run if tool available
+ * @param fallback - Fallback to run if tool not available
+ * @returns Result from action or fallback
+ */
+export declare function withToolFallback<T>(tool: ToolName, action: () => Promise<T>, fallback: () => T | Promise<T>): Promise<T>;
+/**
+ * Execute if tool available, otherwise return undefined
+ */
+export declare function ifToolAvailable<T>(tool: ToolName, action: () => Promise<T>): Promise<T | undefined>;
+/**
+ * Reset the tool availability cache.
+ * Use in tests to ensure fresh checks, or when tool availability may have
+ * changed mid-session (e.g., after installing a tool via `bunx`).
+ *
+ * @example
+ * // In tests
+ * beforeEach(() => resetToolCache());
+ *
+ * @example
+ * // After installing a tool
+ * await installTool('semantic-memory');
+ * resetToolCache();
+ * const available = await isToolAvailable('semantic-memory');
+ */
+export declare function resetToolCache(): void;
+/**
+ * Format tool availability for display
+ */
+export declare function formatToolAvailability(availability: Map<ToolName, ToolAvailability>): string;
+//# sourceMappingURL=tool-availability.d.ts.map

package/dist/tool-availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-availability.d.ts","sourceRoot":"","sources":["../src/tool-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,MAAM,MAAM,QAAQ,GAChB,iBAAiB,GACjB,MAAM,GACN,KAAK,GACL,OAAO,GACP,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAiOD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAWnE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAGtE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC,CAO3B;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAC5C,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAChC,CAyBA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/D;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACxB,QAAQ,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CASxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,GAC5C,MAAM,CAWR"}