opencode-swarm-plugin 0.56.0 → 0.57.0

package/claude-plugin/dist/cass-tools.d.ts

@@ -0,0 +1,74 @@
+/**
+ * CASS Tools - Cross-Agent Session Search
+ *
+ * Provides tools for searching across AI coding agent histories.
+ * Uses inhouse SessionIndexer from swarm-mail package.
+ *
+ * Events emitted:
+ * - cass_searched: When a search is performed
+ * - cass_viewed: When a session is viewed
+ * - cass_indexed: When the index is built/rebuilt
+ */
+export declare const cassTools: {
+    cass_search: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            agent: import("zod").ZodOptional<import("zod").ZodString>;
+            days: import("zod").ZodOptional<import("zod").ZodNumber>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            fields: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            query: string;
+            agent?: string | undefined;
+            days?: number | undefined;
+            limit?: number | undefined;
+            fields?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    cass_view: {
+        description: string;
+        args: {
+            path: import("zod").ZodString;
+            line: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            path: string;
+            line?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    cass_expand: {
+        description: string;
+        args: {
+            path: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            context: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            path: string;
+            line: number;
+            context?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    cass_health: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    cass_index: {
+        description: string;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    cass_stats: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=cass-tools.d.ts.map

package/claude-plugin/dist/cass-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cass-tools.d.ts","sourceRoot":"","sources":["../src/cass-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgaH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOrB,CAAC"}

package/claude-plugin/dist/claude-plugin/claude-plugin-assets.d.ts

@@ -0,0 +1,10 @@
+export type ClaudePluginAssetCopyOptions = {
+    packageRoot: string;
+    distRoot?: string;
+    pluginRoot?: string;
+};
+/**
+ * Copy compiled runtime assets into the Claude plugin root.
+ */
+export declare function copyClaudePluginRuntimeAssets({ packageRoot, distRoot, pluginRoot, }: ClaudePluginAssetCopyOptions): void;
+//# sourceMappingURL=claude-plugin-assets.d.ts.map

package/claude-plugin/dist/claude-plugin/claude-plugin-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-plugin-assets.d.ts","sourceRoot":"","sources":["../../src/claude-plugin/claude-plugin-assets.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,EAC5C,WAAW,EACX,QAAoC,EACpC,UAA+C,GAChD,EAAE,4BAA4B,GAAG,IAAI,CAgBrC"}

package/claude-plugin/dist/compaction-hook.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Swarm-Aware Compaction Hook
+ *
+ * Provides context preservation during OpenCode session compaction.
+ * When context is compacted, this hook injects instructions for the summarizer
+ * to preserve swarm coordination state and enable seamless resumption.
+ *
+ * ## Philosophy: Err on the Side of Continuation
+ *
+ * It's better to inject swarm context unnecessarily than to lose an active swarm.
+ * The cost of a false positive (extra context) is low.
+ * The cost of a false negative (lost swarm) is high - wasted work, confused agents.
+ *
+ * Hook signature (from @opencode-ai/plugin):
+ * ```typescript
+ * "experimental.session.compacting"?: (
+ *   input: { sessionID: string },
+ *   output: { context: string[] }
+ * ) => Promise<void>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { SWARM_COMPACTION_CONTEXT, createCompactionHook } from "opencode-swarm-plugin";
+ *
+ * const hooks: Hooks = {
+ *   "experimental.session.compacting": createCompactionHook(),
+ * };
+ * ```
+ */
+/**
+ * Swarm-aware compaction context
+ *
+ * Injected during compaction to keep the swarm cooking. The coordinator should
+ * wake up from compaction and immediately resume orchestration - spawning agents,
+ * monitoring progress, unblocking work.
+ *
+ * This is NOT about preserving state for a human - it's about the swarm continuing
+ * autonomously after context compression.
+ *
+ * Structure optimized for eval scores:
+ * 1. ASCII header (visual anchor, coordinatorIdentity scorer)
+ * 2. What Good Looks Like (behavioral examples, outcome-focused)
+ * 3. Immediate actions (actionable tool calls, postCompactionDiscipline scorer)
+ * 4. Forbidden tools (explicit list, forbiddenToolsPresent scorer)
+ * 5. Mandatory behaviors (inbox, skills, review)
+ * 6. Role & mandates (strong language, coordinatorIdentity scorer)
+ * 7. Reference sections (supporting material)
+ */
+export declare const SWARM_COMPACTION_CONTEXT: string;
+/**
+ * Fallback detection prompt - tells the compactor what to look for
+ *
+ * Used when we can't definitively detect a swarm but want to be safe.
+ * The compactor can check the conversation context for these patterns.
+ */
+export declare const SWARM_DETECTION_FALLBACK = "## \uD83D\uDC1D Swarm Detection - Check Your Context\n\n**IMPORTANT:** Before summarizing, check if this session involves an active swarm.\n\nLook for ANY of these patterns in the conversation:\n\n### Tool Calls (definite swarm sign)\n- `swarm_decompose`, `swarm_spawn_subtask`, `swarm_status`, `swarm_complete`\n- `swarmmail_init`, `swarmmail_reserve`, `swarmmail_send`\n- `hive_create_epic`, `hive_start`, `hive_close`\n\n### IDs and Names\n- Cell IDs: `bd-xxx`, `bd-xxx.N` (subtask format)\n- Agent names: BlueLake, RedMountain, GreenValley, etc.\n- Epic references: \"epic\", \"subtask\", \"parent\"\n\n### Coordination Language\n- \"spawn\", \"worker\", \"coordinator\"\n- \"reserve\", \"reservation\", \"files\"\n- \"blocked\", \"unblock\", \"dependency\"\n- \"progress\", \"complete\", \"in_progress\"\n\n### If You Find Swarm Evidence\n\nInclude this in your summary:\n1. Epic ID and title\n2. Project path\n3. Subtask status (running/blocked/done/pending)\n4. Any blockers or issues\n5. What should happen next\n\n**Then tell the resumed session:**\n\"This is an active swarm. Check swarm_status and swarmmail_inbox immediately.\"\n";
+/**
+ * SDK Client type (minimal interface for scanSessionMessages)
+ *
+ * The actual SDK client uses a more complex Options-based API:
+ * client.session.messages({ path: { id: sessionID }, query: { limit } })
+ *
+ * We accept `unknown` and handle the type internally to avoid
+ * tight coupling to SDK internals.
+ */
+export type OpencodeClient = unknown;
+/**
+ * Scanned swarm state extracted from session messages
+ */
+export interface ScannedSwarmState {
+    epicId?: string;
+    epicTitle?: string;
+    projectPath?: string;
+    agentName?: string;
+    subtasks: Map<string, {
+        title: string;
+        status: string;
+        worker?: string;
+        files?: string[];
+    }>;
+    lastAction?: {
+        tool: string;
+        args: unknown;
+        timestamp: number;
+    };
+}
+/**
+ * Scan session messages for swarm state using SDK client
+ *
+ * Extracts swarm coordination state from actual tool calls:
+ * - swarm_spawn_subtask → subtask tracking
+ * - swarmmail_init → agent name, project path
+ * - hive_create_epic → epic ID and title
+ * - swarm_status → epic reference
+ * - swarm_complete → subtask completion
+ *
+ * @param client - OpenCode SDK client (undefined if not available)
+ * @param sessionID - Session to scan
+ * @param limit - Max messages to fetch (default 100)
+ * @returns Extracted swarm state
+ */
+export declare function scanSessionMessages(client: OpencodeClient, sessionID: string, limit?: number): Promise<ScannedSwarmState>;
+/**
+ * Options for creating a compaction hook with dependency injection
+ */
+export interface CompactionHookOptions {
+    /** Optional OpenCode SDK client for scanning session messages */
+    client?: OpencodeClient;
+    /** Custom getHiveAdapter function (for testing) */
+    getHiveAdapter?: (projectKey: string) => Promise<{
+        queryCells: (projectKey: string, filters: Record<string, unknown>) => Promise<Array<{
+            id: string;
+            title?: string;
+            type: string;
+            status: string;
+            parent_id: string | null;
+            updated_at: number;
+        }>>;
+    }>;
+    /** Custom checkSwarmHealth function (for testing) */
+    checkSwarmHealth?: (projectKey?: string) => Promise<{
+        healthy: boolean;
+        database: "connected" | "disconnected";
+        stats?: {
+            events: number;
+            agents: number;
+            messages: number;
+            reservations: number;
+        };
+    }>;
+    /** Custom getHiveWorkingDirectory function (for testing) */
+    getHiveWorkingDirectory?: () => string;
+    /** Custom logger instance (for testing) */
+    logger?: {
+        info: (data: unknown, message?: string) => void;
+        debug: (data: unknown, message?: string) => void;
+        warn: (data: unknown, message?: string) => void;
+        error: (data: unknown, message?: string) => void;
+    };
+}
+/**
+ * Create the compaction hook for use in plugin registration
+ *
+ * Injects swarm context based on detection confidence:
+ * - HIGH/MEDIUM: Full swarm context (definitely/probably a swarm)
+ * - LOW: Fallback detection prompt (let compactor check context)
+ * - NONE: No injection (probably not a swarm)
+ *
+ * Philosophy: Err on the side of continuation. A false positive costs
+ * a bit of context space. A false negative loses the swarm.
+ *
+ * @param options - Configuration options including SDK client and dependency injection hooks
+ *
+ * @example
+ * ```typescript
+ * import { createCompactionHook } from "opencode-swarm-plugin";
+ *
+ * export const SwarmPlugin: Plugin = async (input) => ({
+ *   tool: { ... },
+ *   "experimental.session.compacting": createCompactionHook({ client: input.client }),
+ * });
+ * ```
+ *
+ * @example Testing with custom dependencies
+ * ```typescript
+ * const hook = createCompactionHook({
+ *   getHiveAdapter: async () => mockAdapter,
+ *   checkSwarmHealth: async () => mockHealth,
+ * });
+ * ```
+ */
+export declare function createCompactionHook(options?: OpencodeClient | CompactionHookOptions): (input: {
+    sessionID: string;
+}, output: {
+    context: string[];
+}) => Promise<void>;
+//# sourceMappingURL=compaction-hook.d.ts.map

package/claude-plugin/dist/compaction-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-hook.d.ts","sourceRoot":"","sources":["../src/compaction-hook.ts"],"names":[],"mappings":"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"}

package/claude-plugin/dist/compaction-observability.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Compaction Hook Observability
+ *
+ * Structured logging, metrics, and queryable history for the pre-compaction hook.
+ *
+ * **Philosophy:** Make the invisible visible. When patterns aren't extracted,
+ * when detection fails, when timing explodes - we need to know WHY.
+ *
+ * @example
+ * ```typescript
+ * const metrics = createMetricsCollector({ session_id: "abc123" });
+ *
+ * recordPhaseStart(metrics, CompactionPhase.DETECT);
+ * // ... detection logic ...
+ * recordPhaseComplete(metrics, CompactionPhase.DETECT, { confidence: "high" });
+ *
+ * recordPatternExtracted(metrics, "epic_state", "Found epic bd-123");
+ *
+ * const summary = getMetricsSummary(metrics);
+ * console.log(`Detected: ${summary.detected}, Confidence: ${summary.confidence}`);
+ * ```
+ */
+/**
+ * Compaction phases - aligned with existing log structure
+ *
+ * From compaction-hook.ts:
+ * - START: session_id, trigger
+ * - GATHER: source (swarm-mail|hive), duration_ms, stats/counts
+ * - DETECT: confidence, detected, reason_count, reasons
+ * - INJECT: confidence, context_length, context_type (full|fallback|none)
+ * - COMPLETE: duration_ms, success, detected, confidence, context_injected
+ */
+export declare enum CompactionPhase {
+    START = "START",
+    GATHER_SWARM_MAIL = "GATHER_SWARM_MAIL",
+    GATHER_HIVE = "GATHER_HIVE",
+    DETECT = "DETECT",
+    INJECT = "INJECT",
+    COMPLETE = "COMPLETE"
+}
+/**
+ * Phase timing and outcome
+ */
+interface PhaseMetrics {
+    duration_ms: number;
+    success: boolean;
+    error?: string;
+    /** Additional phase-specific data */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Pattern extraction record
+ */
+interface PatternRecord {
+    pattern_type: string;
+    reason: string;
+    /** Debug details (only captured if debug mode enabled) */
+    details?: Record<string, unknown>;
+    timestamp: number;
+}
+/**
+ * Compaction metrics collector
+ *
+ * Mutable state object that accumulates metrics during a compaction run.
+ */
+export interface CompactionMetrics {
+    /** Session metadata */
+    session_id?: string;
+    has_sdk_client?: boolean;
+    debug?: boolean;
+    /** Phase timings */
+    phases: Map<CompactionPhase, {
+        start_time: number;
+        end_time?: number;
+        metadata?: Record<string, unknown>;
+        error?: string;
+    }>;
+    /** Pattern extraction tracking */
+    extracted: PatternRecord[];
+    skipped: PatternRecord[];
+    /** Final detection result */
+    confidence?: "high" | "medium" | "low" | "none";
+    detected?: boolean;
+    /** Overall timing */
+    start_time: number;
+    end_time?: number;
+}
+/**
+ * Metrics summary (read-only snapshot)
+ */
+export interface CompactionMetricsSummary {
+    session_id?: string;
+    has_sdk_client?: boolean;
+    /** Phase breakdown */
+    phases: Record<string, PhaseMetrics>;
+    /** Pattern extraction stats */
+    patterns_extracted: number;
+    patterns_skipped: number;
+    extraction_success_rate: number;
+    extracted_patterns: string[];
+    skipped_patterns: string[];
+    /** Detection outcome */
+    confidence?: "high" | "medium" | "low" | "none";
+    detected?: boolean;
+    /** Timing */
+    total_duration_ms: number;
+    /** Debug info (only if debug mode enabled) */
+    debug_info?: Array<{
+        phase: string;
+        pattern: string;
+        details: Record<string, unknown>;
+    }>;
+}
+/**
+ * Create a metrics collector
+ *
+ * @param metadata - Session metadata to capture
+ * @returns Mutable metrics collector
+ */
+export declare function createMetricsCollector(metadata?: {
+    session_id?: string;
+    has_sdk_client?: boolean;
+    debug?: boolean;
+}): CompactionMetrics;
+/**
+ * Record phase start
+ *
+ * @param metrics - Metrics collector
+ * @param phase - Phase being started
+ */
+export declare function recordPhaseStart(metrics: CompactionMetrics, phase: CompactionPhase): void;
+/**
+ * Record phase completion
+ *
+ * @param metrics - Metrics collector
+ * @param phase - Phase being completed
+ * @param result - Phase outcome
+ */
+export declare function recordPhaseComplete(metrics: CompactionMetrics, phase: CompactionPhase, result?: {
+    success?: boolean;
+    error?: string;
+    confidence?: "high" | "medium" | "low" | "none";
+    detected?: boolean;
+    [key: string]: unknown;
+}): void;
+/**
+ * Record an extracted pattern
+ *
+ * @param metrics - Metrics collector
+ * @param pattern_type - Type of pattern extracted (e.g., "epic_state", "agent_name")
+ * @param reason - Human-readable reason for extraction
+ * @param details - Debug details (only captured if debug mode enabled)
+ */
+export declare function recordPatternExtracted(metrics: CompactionMetrics, pattern_type: string, reason: string, details?: Record<string, unknown>): void;
+/**
+ * Record a skipped pattern
+ *
+ * @param metrics - Metrics collector
+ * @param pattern_type - Type of pattern that was skipped
+ * @param reason - Human-readable reason for skipping
+ */
+export declare function recordPatternSkipped(metrics: CompactionMetrics, pattern_type: string, reason: string): void;
+/**
+ * Get metrics summary (read-only snapshot)
+ *
+ * Computes derived metrics like success rates and total duration.
+ *
+ * @param metrics - Metrics collector
+ * @returns Immutable summary
+ */
+export declare function getMetricsSummary(metrics: CompactionMetrics): CompactionMetricsSummary;
+export {};
+//# sourceMappingURL=compaction-observability.d.ts.map

package/claude-plugin/dist/compaction-observability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-observability.d.ts","sourceRoot":"","sources":["../src/compaction-observability.ts"],"names":[],"mappings":"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"}

package/claude-plugin/dist/compaction-prompt-scoring.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Compaction Prompt Quality Scoring - Pure Functions
+ *
+ * Evaluates the quality of continuation prompts generated after context compaction.
+ * **Problem**: Post-compaction coordinators often "wake up" confused, forget their role,
+ * and start editing files instead of checking worker status.
+ *
+ * **Solution**: Score prompts on 5 dimensions that predict coordinator success:
+ *
+ * 1. **Epic ID Specificity (0.20)**: Real IDs (`mjkw...`) not placeholders (`<epic-id>`, `bd-xxx`)
+ *    - Placeholders = coordinator can't check actual swarm status
+ *
+ * 2. **Actionability (0.20)**: Tool calls with real values (e.g., `swarm_status(epic_id='mjkw81rkq4c')`)
+ *    - Generic instructions like "check status" don't work
+ *
+ * 3. **Coordinator Identity (0.25)**: ASCII header + strong mandates (NEVER/ALWAYS)
+ *    - Visual + semantic cues reinforce role post-compaction
+ *
+ * 4. **Forbidden Tools Listed (0.15)**: Explicitly lists Edit, Write, swarmmail_reserve, git commit
+ *    - Naming forbidden tools reduces violations
+ *
+ * 5. **Post-Compaction Discipline (0.20)**: First suggested tool is swarm_status or inbox (not Edit)
+ *    - First tool sets the pattern - "check status" vs "dive into code"
+ *
+ * **Pure functions**: These can be tested without evalite. The evalite wrappers are in
+ * `evals/scorers/compaction-prompt-scorers.ts`.
+ *
+ * **Data source**: Captured from `captureCompactionEvent()` with `compaction_type: "prompt_generated"`.
+ * The payload includes the FULL prompt content (not truncated) for scoring.
+ *
+ * **Integration**: `compaction-prompt.eval.ts` uses these scorers to track prompt quality over time.
+ * Progressive gates enforce quality: bootstrap → stabilization → production.
+ *
+ * @module compaction-prompt-scoring
+ */
+/**
+ * Compaction prompt structure (from LLM generation)
+ */
+export interface CompactionPrompt {
+    content: string;
+}
+/**
+ * Scorer result type
+ */
+export interface ScorerResult {
+    score: number;
+    message: string;
+}
+/** Matches real epic/cell IDs (mjkw prefix + 7+ base36 chars) */
+export declare const REAL_EPIC_ID: RegExp;
+/** Matches common placeholder patterns */
+export declare const PLACEHOLDERS: RegExp[];
+/** Matches ASCII box-drawing characters (for headers) */
+export declare const ASCII_BOX: RegExp;
+/** Matches strong mandate language */
+export declare const STRONG_LANGUAGE: RegExp[];
+/**
+ * Score epic ID specificity
+ *
+ * Validates that epic IDs are REAL, not placeholders.
+ * Placeholders like <epic-id>, bd-xxx, <path> indicate
+ * the prompt generator failed to inject actual values.
+ *
+ * @returns 1.0 if real IDs, 0.0 if placeholders found
+ */
+export declare function scoreEpicIdSpecificity(prompt: CompactionPrompt): ScorerResult;
+/**
+ * Score actionability of tool calls
+ *
+ * Validates that the prompt includes SPECIFIC actionable tool calls.
+ * Generic instructions like "check status" are useless.
+ * Good: swarm_status(epic_id='mjkw81rkq4c', project_key='/path')
+ * Bad: "Check the status of workers"
+ *
+ * @returns 1.0 if actionable tool calls with real values, 0.0 otherwise
+ */
+export declare function scoreActionability(prompt: CompactionPrompt): ScorerResult;
+/**
+ * Score coordinator identity reinforcement
+ *
+ * Validates that the prompt has STRONG coordinator identity reinforcement.
+ * Post-compaction coordinators lose their identity without visual+semantic cues.
+ *
+ * Checks:
+ * 1. ASCII box header (visual anchor)
+ * 2. Strong language (NEVER/ALWAYS, not "should"/"consider")
+ *
+ * @returns 1.0 for ASCII header + strong mandates, 0.5 for header only, 0.0 otherwise
+ */
+export declare function scoreCoordinatorIdentity(prompt: CompactionPrompt): ScorerResult;
+/**
+ * Score forbidden tools listing
+ *
+ * Validates that the prompt LISTS forbidden tools by name.
+ * Coordinators must know exactly which tools to avoid.
+ *
+ * Required forbidden tools:
+ * 1. Edit
+ * 2. Write
+ * 3. swarmmail_reserve (only workers reserve)
+ * 4. git commit (workers commit)
+ * 5. bash (for file modifications)
+ *
+ * @returns ratio of forbidden tools mentioned (0.0 to 1.0)
+ */
+export declare function scoreForbiddenToolsPresent(prompt: CompactionPrompt): ScorerResult;
+/**
+ * Score post-compaction discipline (first tool correctness)
+ *
+ * Validates that the FIRST suggested tool is correct.
+ * Coordinators should check status FIRST, not edit files.
+ *
+ * Good first tools:
+ * - swarm_status
+ * - swarmmail_inbox
+ *
+ * Bad first tools:
+ * - Edit
+ * - Write
+ * - Read (should check status first)
+ *
+ * @returns 1.0 if first tool is swarm_status or inbox, 0.0 otherwise
+ */
+export declare function scorePostCompactionDiscipline(prompt: CompactionPrompt): ScorerResult;
+//# sourceMappingURL=compaction-prompt-scoring.d.ts.map

package/claude-plugin/dist/compaction-prompt-scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-prompt-scoring.d.ts","sourceRoot":"","sources":["../src/compaction-prompt-scoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAID,iEAAiE;AACjE,eAAO,MAAM,YAAY,QAAqB,CAAC;AAE/C,0CAA0C;AAC1C,eAAO,MAAM,YAAY,UAKxB,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,SAAS,QAAiB,CAAC;AAExC,sCAAsC;AACtC,eAAO,MAAM,eAAe,UAAoD,CAAC;AAIjF;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,YAAY,CAuB7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,YAAY,CA+BzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,gBAAgB,GACtB,YAAY,CA6Bd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,gBAAgB,GACtB,YAAY,CAkCd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,gBAAgB,GACtB,YAAY,CAiCd"}