opencode-swarm-plugin 0.22.0 → 0.23.0

package/dist/anti-patterns.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Anti-Pattern Learning Module
+ *
+ * Tracks failed decomposition patterns and auto-inverts them to anti-patterns.
+ * When a pattern consistently fails, it gets flagged as something to avoid.
+ *
+ * @see https://github.com/Dicklesworthstone/cass_memory_system/blob/main/src/curate.ts#L95-L117
+ */
+import { z } from "zod";
+/**
+ * Pattern kind - whether this is a positive pattern or an anti-pattern
+ */
+export declare const PatternKindSchema: z.ZodEnum<{
+    pattern: "pattern";
+    anti_pattern: "anti_pattern";
+}>;
+export type PatternKind = z.infer<typeof PatternKindSchema>;
+/**
+ * Decomposition pattern with success/failure tracking.
+ *
+ * Field relationships:
+ * - `kind`: Tracks pattern lifecycle ("pattern" → "anti_pattern" when failure rate exceeds threshold)
+ * - `is_negative`: Derived boolean flag for quick filtering (true when kind === "anti_pattern")
+ *
+ * Both fields exist because:
+ * - `kind` is the source of truth for pattern status
+ * - `is_negative` enables efficient filtering without string comparison
+ */
+export declare const DecompositionPatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    kind: z.ZodEnum<{
+        pattern: "pattern";
+        anti_pattern: "anti_pattern";
+    }>;
+    is_negative: z.ZodBoolean;
+    success_count: z.ZodDefault<z.ZodNumber>;
+    failure_count: z.ZodDefault<z.ZodNumber>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DecompositionPattern = z.infer<typeof DecompositionPatternSchema>;
+/**
+ * Result of pattern inversion
+ */
+export declare const PatternInversionResultSchema: z.ZodObject<{
+    original: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            pattern: "pattern";
+            anti_pattern: "anti_pattern";
+        }>;
+        is_negative: z.ZodBoolean;
+        success_count: z.ZodDefault<z.ZodNumber>;
+        failure_count: z.ZodDefault<z.ZodNumber>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    inverted: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            pattern: "pattern";
+            anti_pattern: "anti_pattern";
+        }>;
+        is_negative: z.ZodBoolean;
+        success_count: z.ZodDefault<z.ZodNumber>;
+        failure_count: z.ZodDefault<z.ZodNumber>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type PatternInversionResult = z.infer<typeof PatternInversionResultSchema>;
+/**
+ * Configuration for anti-pattern detection
+ */
+export interface AntiPatternConfig {
+    /** Minimum observations before considering inversion */
+    minObservations: number;
+    /** Failure ratio threshold for inversion (0-1) */
+    failureRatioThreshold: number;
+    /** Prefix for anti-pattern content */
+    antiPatternPrefix: string;
+}
+export declare const DEFAULT_ANTI_PATTERN_CONFIG: AntiPatternConfig;
+/**
+ * Check if a pattern should be inverted to an anti-pattern
+ *
+ * A pattern is inverted when:
+ * 1. It has enough observations (minObservations)
+ * 2. Its failure ratio exceeds the threshold
+ *
+ * @param pattern - The pattern to check
+ * @param config - Anti-pattern configuration
+ * @returns Whether the pattern should be inverted
+ */
+export declare function shouldInvertPattern(pattern: DecompositionPattern, config?: AntiPatternConfig): boolean;
+/**
+ * Invert a pattern to an anti-pattern
+ *
+ * Creates a new anti-pattern from a failing pattern.
+ * The content is prefixed with "AVOID: " and the kind is changed.
+ *
+ * @param pattern - The pattern to invert
+ * @param reason - Why the inversion is happening
+ * @param config - Anti-pattern configuration
+ * @returns The inverted anti-pattern
+ */
+export declare function invertToAntiPattern(pattern: DecompositionPattern, reason: string, config?: AntiPatternConfig): PatternInversionResult;
+/**
+ * Record a pattern observation (success or failure)
+ *
+ * Updates the pattern's success/failure counts and checks if
+ * it should be inverted to an anti-pattern.
+ *
+ * @param pattern - The pattern to update
+ * @param success - Whether this observation was successful
+ * @param beadId - Optional bead ID to record as example
+ * @param config - Anti-pattern configuration
+ * @returns Updated pattern and optional inversion result
+ */
+export declare function recordPatternObservation(pattern: DecompositionPattern, success: boolean, beadId?: string, config?: AntiPatternConfig): {
+    pattern: DecompositionPattern;
+    inversion?: PatternInversionResult;
+};
+/**
+ * Extract patterns from a decomposition description
+ *
+ * Looks for common decomposition strategies in the text.
+ *
+ * @param description - Decomposition description or reasoning
+ * @returns Extracted pattern descriptions
+ */
+export declare function extractPatternsFromDescription(description: string): string[];
+/**
+ * Create a new pattern from a description
+ *
+ * @param content - Pattern description
+ * @param tags - Optional tags for categorization
+ * @returns New pattern
+ */
+export declare function createPattern(content: string, tags?: string[]): DecompositionPattern;
+/**
+ * Format anti-patterns for inclusion in decomposition prompts
+ *
+ * @param patterns - Anti-patterns to format
+ * @returns Formatted string for prompt inclusion
+ */
+export declare function formatAntiPatternsForPrompt(patterns: DecompositionPattern[]): string;
+/**
+ * Format successful patterns for inclusion in prompts.
+ *
+ * @param patterns - Array of decomposition patterns to filter and format
+ * @param minSuccessRate - Minimum success rate to include (default 0.7 = 70%).
+ *   Chosen to filter out patterns with marginal track records - only patterns
+ *   that succeed at least 70% of the time are recommended.
+ * @returns Formatted string of successful patterns for prompt injection
+ */
+export declare function formatSuccessfulPatternsForPrompt(patterns: DecompositionPattern[], minSuccessRate?: number): string;
+/**
+ * Storage interface for decomposition patterns
+ */
+export interface PatternStorage {
+    /** Store or update a pattern */
+    store(pattern: DecompositionPattern): Promise<void>;
+    /** Get a pattern by ID */
+    get(id: string): Promise<DecompositionPattern | null>;
+    /** Get all patterns */
+    getAll(): Promise<DecompositionPattern[]>;
+    /** Get all anti-patterns */
+    getAntiPatterns(): Promise<DecompositionPattern[]>;
+    /** Get patterns by tag */
+    getByTag(tag: string): Promise<DecompositionPattern[]>;
+    /** Find patterns matching content */
+    findByContent(content: string): Promise<DecompositionPattern[]>;
+}
+/**
+ * In-memory pattern storage (for testing and short-lived sessions)
+ */
+export declare class InMemoryPatternStorage implements PatternStorage {
+    private patterns;
+    store(pattern: DecompositionPattern): Promise<void>;
+    get(id: string): Promise<DecompositionPattern | null>;
+    getAll(): Promise<DecompositionPattern[]>;
+    getAntiPatterns(): Promise<DecompositionPattern[]>;
+    getByTag(tag: string): Promise<DecompositionPattern[]>;
+    findByContent(content: string): Promise<DecompositionPattern[]>;
+}
+export declare const antiPatternSchemas: {
+    PatternKindSchema: z.ZodEnum<{
+        pattern: "pattern";
+        anti_pattern: "anti_pattern";
+    }>;
+    DecompositionPatternSchema: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            pattern: "pattern";
+            anti_pattern: "anti_pattern";
+        }>;
+        is_negative: z.ZodBoolean;
+        success_count: z.ZodDefault<z.ZodNumber>;
+        failure_count: z.ZodDefault<z.ZodNumber>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    PatternInversionResultSchema: z.ZodObject<{
+        original: z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            kind: z.ZodEnum<{
+                pattern: "pattern";
+                anti_pattern: "anti_pattern";
+            }>;
+            is_negative: z.ZodBoolean;
+            success_count: z.ZodDefault<z.ZodNumber>;
+            failure_count: z.ZodDefault<z.ZodNumber>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        inverted: z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            kind: z.ZodEnum<{
+                pattern: "pattern";
+                anti_pattern: "anti_pattern";
+            }>;
+            is_negative: z.ZodBoolean;
+            success_count: z.ZodDefault<z.ZodNumber>;
+            failure_count: z.ZodDefault<z.ZodNumber>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            example_beads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        reason: z.ZodString;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=anti-patterns.d.ts.map

package/dist/anti-patterns.d.ts.map

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

package/dist/beads.d.ts

@@ -0,0 +1,377 @@
+import { z } from "zod";
+/**
+ * Set the working directory for all beads commands.
+ * Call this from the plugin initialization with the project directory.
+ *
+ * @param directory - Absolute path to the project directory
+ */
+export declare function setBeadsWorkingDirectory(directory: string): void;
+/**
+ * Get the current working directory for beads commands.
+ * Returns the configured directory or process.cwd() as fallback.
+ */
+export declare function getBeadsWorkingDirectory(): string;
+/**
+ * Custom error for bead operations
+ */
+export declare class BeadError extends Error {
+    readonly command: string;
+    readonly exitCode?: number | undefined;
+    readonly stderr?: string | undefined;
+    constructor(message: string, command: string, exitCode?: number | undefined, stderr?: string | undefined);
+}
+/**
+ * Custom error for validation failures
+ */
+export declare class BeadValidationError extends Error {
+    readonly zodError: z.ZodError;
+    constructor(message: string, zodError: z.ZodError);
+}
+/**
+ * Create a new bead with type-safe validation
+ */
+export declare const beads_create: {
+    description: string;
+    args: {
+        title: z.ZodString;
+        type: z.ZodOptional<z.ZodEnum<{
+            bug: "bug";
+            feature: "feature";
+            task: "task";
+            epic: "epic";
+            chore: "chore";
+        }>>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        parent_id: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        title: string;
+        type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+        priority?: number | undefined;
+        description?: string | undefined;
+        parent_id?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Create an epic with subtasks in one atomic operation
+ */
+export declare const beads_create_epic: {
+    description: string;
+    args: {
+        epic_title: z.ZodString;
+        epic_description: z.ZodOptional<z.ZodString>;
+        epic_id: z.ZodOptional<z.ZodString>;
+        subtasks: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            priority: z.ZodOptional<z.ZodNumber>;
+            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            id_suffix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            "file-based": "file-based";
+            "feature-based": "feature-based";
+            "risk-based": "risk-based";
+        }>>;
+        task: z.ZodOptional<z.ZodString>;
+        project_key: z.ZodOptional<z.ZodString>;
+        recovery_context: z.ZodOptional<z.ZodObject<{
+            shared_context: z.ZodOptional<z.ZodString>;
+            skills_to_load: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            coordinator_notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    execute(args: {
+        epic_title: string;
+        subtasks: {
+            title: string;
+            priority?: number | undefined;
+            files?: string[] | undefined;
+            id_suffix?: string | undefined;
+        }[];
+        epic_description?: string | undefined;
+        epic_id?: string | undefined;
+        strategy?: "file-based" | "feature-based" | "risk-based" | undefined;
+        task?: string | undefined;
+        project_key?: 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>;
+};
+/**
+ * Query beads with filters
+ */
+export declare const beads_query: {
+    description: string;
+    args: {
+        status: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            in_progress: "in_progress";
+            blocked: "blocked";
+            closed: "closed";
+        }>>;
+        type: z.ZodOptional<z.ZodEnum<{
+            bug: "bug";
+            feature: "feature";
+            task: "task";
+            epic: "epic";
+            chore: "chore";
+        }>>;
+        ready: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+        type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+        ready?: boolean | undefined;
+        limit?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Update a bead's status or description
+ */
+export declare const beads_update: {
+    description: string;
+    args: {
+        id: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            in_progress: "in_progress";
+            blocked: "blocked";
+            closed: "closed";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        id: string;
+        status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+        description?: string | undefined;
+        priority?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Close a bead with reason
+ */
+export declare const beads_close: {
+    description: string;
+    args: {
+        id: z.ZodString;
+        reason: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+        reason: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Mark a bead as in-progress
+ */
+export declare const beads_start: {
+    description: string;
+    args: {
+        id: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get the next ready bead
+ */
+export declare const beads_ready: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Sync beads to git and push
+ */
+export declare const beads_sync: {
+    description: string;
+    args: {
+        auto_pull: z.ZodOptional<z.ZodBoolean>;
+    };
+    execute(args: {
+        auto_pull?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Link a bead to an Agent Mail thread
+ */
+export declare const beads_link_thread: {
+    description: string;
+    args: {
+        bead_id: z.ZodString;
+        thread_id: z.ZodString;
+    };
+    execute(args: {
+        bead_id: string;
+        thread_id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const beadsTools: {
+    beads_create: {
+        description: string;
+        args: {
+            title: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                bug: "bug";
+                feature: "feature";
+                task: "task";
+                epic: "epic";
+                chore: "chore";
+            }>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+            parent_id: z.ZodOptional<z.ZodString>;
+        };
+        execute(args: {
+            title: string;
+            type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+            priority?: number | undefined;
+            description?: string | undefined;
+            parent_id?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_create_epic: {
+        description: string;
+        args: {
+            epic_title: z.ZodString;
+            epic_description: z.ZodOptional<z.ZodString>;
+            epic_id: z.ZodOptional<z.ZodString>;
+            subtasks: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                priority: z.ZodOptional<z.ZodNumber>;
+                files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                id_suffix: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            strategy: z.ZodOptional<z.ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+            }>>;
+            task: z.ZodOptional<z.ZodString>;
+            project_key: z.ZodOptional<z.ZodString>;
+            recovery_context: z.ZodOptional<z.ZodObject<{
+                shared_context: z.ZodOptional<z.ZodString>;
+                skills_to_load: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                coordinator_notes: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        };
+        execute(args: {
+            epic_title: string;
+            subtasks: {
+                title: string;
+                priority?: number | undefined;
+                files?: string[] | undefined;
+                id_suffix?: string | undefined;
+            }[];
+            epic_description?: string | undefined;
+            epic_id?: string | undefined;
+            strategy?: "file-based" | "feature-based" | "risk-based" | undefined;
+            task?: string | undefined;
+            project_key?: 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>;
+    };
+    beads_query: {
+        description: string;
+        args: {
+            status: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                in_progress: "in_progress";
+                blocked: "blocked";
+                closed: "closed";
+            }>>;
+            type: z.ZodOptional<z.ZodEnum<{
+                bug: "bug";
+                feature: "feature";
+                task: "task";
+                epic: "epic";
+                chore: "chore";
+            }>>;
+            ready: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        };
+        execute(args: {
+            status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+            type?: "bug" | "feature" | "task" | "epic" | "chore" | undefined;
+            ready?: boolean | undefined;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_update: {
+        description: string;
+        args: {
+            id: z.ZodString;
+            status: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                in_progress: "in_progress";
+                blocked: "blocked";
+                closed: "closed";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+        };
+        execute(args: {
+            id: string;
+            status?: "open" | "in_progress" | "blocked" | "closed" | undefined;
+            description?: string | undefined;
+            priority?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_close: {
+        description: string;
+        args: {
+            id: z.ZodString;
+            reason: z.ZodString;
+        };
+        execute(args: {
+            id: string;
+            reason: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_start: {
+        description: string;
+        args: {
+            id: z.ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_ready: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_sync: {
+        description: string;
+        args: {
+            auto_pull: z.ZodOptional<z.ZodBoolean>;
+        };
+        execute(args: {
+            auto_pull?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    beads_link_thread: {
+        description: string;
+        args: {
+            bead_id: z.ZodString;
+            thread_id: z.ZodString;
+        };
+        execute(args: {
+            bead_id: string;
+            thread_id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=beads.d.ts.map

package/dist/beads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beads.d.ts","sourceRoot":"","sources":["../src/beads.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AA+DD;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;aAGhB,OAAO,EAAE,MAAM;aACf,QAAQ,CAAC,EAAE,MAAM;aACjB,MAAM,CAAC,EAAE,MAAM;gBAH/B,OAAO,EAAE,MAAM,EACC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,YAAA,EACjB,MAAM,CAAC,EAAE,MAAM,YAAA;CAKlC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAG1B,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBADpC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,CAAC,CAAC,QAAQ;CAKvC;AA+FD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;CA4DvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsM5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAoDtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CA6CvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CA+BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;CA0BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAuBtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;CAqMrB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;CAkD5B,CAAC;AAMH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUtB,CAAC"}