opencode-swarm-plugin 0.56.1 → 0.57.0

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

@@ -0,0 +1,281 @@
+/**
+ * Semantic Memory Plugin Tools - Embedded implementation
+ *
+ * Provides semantic memory operations using swarm-mail's MemoryStore + Ollama.
+ * Replaces external MCP-based semantic-memory calls with embedded storage.
+ *
+ * Key features:
+ * - Vector similarity search with Ollama embeddings
+ * - Full-text search fallback
+ * - Memory decay tracking (TODO: implement in MemoryStore)
+ * - Collection-based organization
+ *
+ * Tool signatures maintained for backward compatibility with existing prompts.
+ */
+import { createMemoryAdapter, type MemoryAdapter } from "./memory";
+export type { MemoryAdapter, StoreArgs, FindArgs, IdArgs, ListArgs, StoreResult, FindResult, StatsResult, HealthResult, OperationResult, UpsertArgs, UpsertResult, AutoTags, } from "./memory";
+/**
+ * Get or create memory adapter for the current project
+ *
+ * @param projectPath - Project path (uses CWD if not provided)
+ * @returns Memory adapter instance
+ */
+export declare function getMemoryAdapter(projectPath?: string): Promise<MemoryAdapter>;
+/**
+ * Reset adapter cache (for testing)
+ */
+export declare function resetMemoryCache(): void;
+export { createMemoryAdapter };
+/**
+ * Store a memory with semantic embedding
+ */
+export declare const semantic_memory_store: {
+    description: string;
+    args: {
+        information: import("zod").ZodString;
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodString>;
+        confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        information: string;
+        collection?: string | undefined;
+        tags?: string | undefined;
+        metadata?: string | undefined;
+        confidence?: number | undefined;
+        autoTag?: boolean | undefined;
+        autoLink?: boolean | undefined;
+        extractEntities?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Find memories by semantic similarity or full-text search
+ */
+export declare const semantic_memory_find: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+        expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        query: string;
+        limit?: number | undefined;
+        collection?: string | undefined;
+        expand?: boolean | undefined;
+        fts?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get a single memory by ID
+ */
+export declare const semantic_memory_get: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Remove a memory
+ */
+export declare const semantic_memory_remove: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Validate a memory (reset decay timer)
+ */
+export declare const semantic_memory_validate: {
+    description: string;
+    args: {
+        id: import("zod").ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * List memories
+ */
+export declare const semantic_memory_list: {
+    description: string;
+    args: {
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        collection?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Get memory statistics
+ */
+export declare const semantic_memory_stats: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Check Ollama health
+ */
+export declare const semantic_memory_check: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Smart upsert - ADD, UPDATE, DELETE, or NOOP based on existing memories
+ */
+export declare const semantic_memory_upsert: {
+    description: string;
+    args: {
+        information: import("zod").ZodString;
+        collection: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodString>;
+        confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        information: string;
+        collection?: string | undefined;
+        tags?: string | undefined;
+        metadata?: string | undefined;
+        confidence?: number | undefined;
+        autoTag?: boolean | undefined;
+        autoLink?: boolean | undefined;
+        extractEntities?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * All semantic memory tools
+ *
+ * Register these in the plugin with spread operator: { ...memoryTools }
+ */
+export declare const memoryTools: {
+    readonly "semantic-memory_store": {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_find": {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            expand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            fts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            query: string;
+            limit?: number | undefined;
+            collection?: string | undefined;
+            expand?: boolean | undefined;
+            fts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_get": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_remove": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_validate": {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_list": {
+        description: string;
+        args: {
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            collection?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_stats": {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_check": {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    readonly "semantic-memory_upsert": {
+        description: string;
+        args: {
+            information: import("zod").ZodString;
+            collection: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+            autoTag: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            autoLink: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            extractEntities: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            information: string;
+            collection?: string | undefined;
+            tags?: string | undefined;
+            metadata?: string | undefined;
+            confidence?: number | undefined;
+            autoTag?: boolean | undefined;
+            autoLink?: boolean | undefined;
+            extractEntities?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+//# sourceMappingURL=memory-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-tools.d.ts","sourceRoot":"","sources":["../src/memory-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EACN,mBAAmB,EACnB,KAAK,aAAa,EAalB,MAAM,UAAU,CAAC;AAGlB,YAAY,EACX,aAAa,EACb,SAAS,EACT,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,eAAe,EACf,UAAU,EACV,YAAY,EACZ,QAAQ,GACR,MAAM,UAAU,CAAC;AAkBlB;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACrC,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,aAAa,CAAC,CAiBxB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAGD,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAM/B;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;CA4DhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CAgD/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAU9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CA0BjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;CA4BnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;CAa/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAQhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAShC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;CAyDjC,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUd,CAAC"}

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

@@ -0,0 +1,164 @@
+/**
+ * Memory Module - Semantic Memory Adapter
+ *
+ * Provides a high-level adapter around swarm-mail's MemoryStore + Ollama.
+ * Used by semantic-memory_* tools in the plugin.
+ *
+ * ## Design
+ * - Wraps MemoryStore (vector storage) + Ollama (embeddings)
+ * - Handles ID generation, metadata parsing, error handling
+ * - Tool-friendly API (string inputs/outputs, no Effect-TS in signatures)
+ *
+ * ## Usage
+ * ```typescript
+ * const adapter = await createMemoryAdapter(swarmMail.db);
+ *
+ * // Store memory
+ * const { id } = await adapter.store({
+ *   information: "OAuth tokens need 5min buffer",
+ *   tags: "auth,tokens",
+ * });
+ *
+ * // Search memories
+ * const results = await adapter.find({
+ *   query: "token refresh",
+ *   limit: 5,
+ * });
+ * ```
+ */
+import { type DatabaseAdapter, type Memory } from "swarm-mail";
+/**
+ * Reset migration check flag (for testing)
+ * @internal
+ */
+export declare function resetMigrationCheck(): void;
+/** Arguments for store operation */
+export interface StoreArgs {
+    readonly information: string;
+    readonly collection?: string;
+    readonly tags?: string;
+    readonly metadata?: string;
+    /** Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7 */
+    readonly confidence?: number;
+    /** Auto-generate tags using LLM. Default false */
+    readonly autoTag?: boolean;
+    /** Auto-link to related memories. Default false */
+    readonly autoLink?: boolean;
+    /** Extract entities (people, places, technologies). Default false */
+    readonly extractEntities?: boolean;
+}
+/** Arguments for find operation */
+export interface FindArgs {
+    readonly query: string;
+    readonly limit?: number;
+    readonly collection?: string;
+    readonly expand?: boolean;
+    readonly fts?: boolean;
+}
+/** Arguments for get/remove/validate operations */
+export interface IdArgs {
+    readonly id: string;
+}
+/** Arguments for list operation */
+export interface ListArgs {
+    readonly collection?: string;
+}
+/** Result from store operation */
+export interface StoreResult {
+    readonly id: string;
+    readonly message: string;
+}
+/** Result from find operation */
+export interface FindResult {
+    readonly results: Array<{
+        readonly id: string;
+        readonly content: string;
+        readonly score: number;
+        readonly collection: string;
+        readonly metadata: Record<string, unknown>;
+        readonly createdAt: string;
+    }>;
+    readonly count: number;
+}
+/** Result from stats operation */
+export interface StatsResult {
+    readonly memories: number;
+    readonly embeddings: number;
+}
+/** Result from health check */
+export interface HealthResult {
+    readonly ollama: boolean;
+    readonly message?: string;
+}
+/** Result from validate/remove operations */
+export interface OperationResult {
+    readonly success: boolean;
+    readonly message?: string;
+}
+/** Arguments for upsert operation */
+export interface UpsertArgs {
+    readonly information: string;
+    readonly collection?: string;
+    readonly tags?: string;
+    readonly metadata?: string;
+    readonly confidence?: number;
+    /** Auto-generate tags using LLM. Default true */
+    readonly autoTag?: boolean;
+    /** Auto-link to related memories. Default true */
+    readonly autoLink?: boolean;
+    /** Extract entities (people, places, technologies). Default false */
+    readonly extractEntities?: boolean;
+}
+/** Auto-generated tags result */
+export interface AutoTags {
+    readonly tags: string[];
+    readonly keywords: string[];
+    readonly category: string;
+}
+/** Result from upsert operation */
+export interface UpsertResult {
+    readonly operation: "ADD" | "UPDATE" | "DELETE" | "NOOP";
+    readonly reason: string;
+    readonly memoryId?: string;
+    readonly affectedMemoryIds?: string[];
+    readonly autoTags?: AutoTags;
+    readonly linksCreated?: number;
+    readonly entitiesExtracted?: number;
+}
+/**
+ * Memory Adapter Interface
+ *
+ * High-level API for semantic memory operations.
+ */
+export interface MemoryAdapter {
+    readonly store: (args: StoreArgs) => Promise<StoreResult>;
+    readonly find: (args: FindArgs) => Promise<FindResult>;
+    readonly get: (args: IdArgs) => Promise<Memory | null>;
+    readonly remove: (args: IdArgs) => Promise<OperationResult>;
+    readonly validate: (args: IdArgs) => Promise<OperationResult>;
+    readonly list: (args: ListArgs) => Promise<Memory[]>;
+    readonly stats: () => Promise<StatsResult>;
+    readonly checkHealth: () => Promise<HealthResult>;
+    readonly upsert: (args: UpsertArgs) => Promise<UpsertResult>;
+}
+/**
+ * Create Memory Adapter
+ *
+ * @param db - DatabaseAdapter from swarm-mail's getDatabase()
+ * @returns Memory adapter with high-level operations
+ *
+ * @example
+ * ```typescript
+ * import { getSwarmMailLibSQL } from 'swarm-mail';
+ * import { createMemoryAdapter } from './memory';
+ *
+ * const swarmMail = await getSwarmMailLibSQL('/path/to/project');
+ * const db = await swarmMail.getDatabase();
+ * const adapter = await createMemoryAdapter(db);
+ *
+ * await adapter.store({ information: "Learning X" });
+ * const results = await adapter.find({ query: "X" });
+ * ```
+ */
+export declare function createMemoryAdapter(db: DatabaseAdapter): Promise<MemoryAdapter>;
+//# sourceMappingURL=memory.d.ts.map

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

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

package/claude-plugin/dist/model-selection.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model Selection Module
+ *
+ * Determines which model a worker agent should use based on subtask
+ * characteristics like file types and complexity.
+ *
+ * Priority:
+ * 1. Explicit model field in subtask
+ * 2. File-type inference (docs/tests → lite model)
+ * 3. Default to primary model
+ */
+import type { DecomposedSubtask } from "./schemas/task";
+/**
+ * Configuration interface for swarm models
+ */
+export interface SwarmConfig {
+    primaryModel: string;
+    liteModel?: string;
+}
+/**
+ * Select the appropriate model for a worker agent based on subtask characteristics
+ *
+ * Priority order:
+ * 1. Explicit `model` field in subtask (if present)
+ * 2. File-type inference:
+ *    - All .md/.mdx files → liteModel
+ *    - All .test./.spec. files → liteModel
+ * 3. Mixed files or implementation → primaryModel
+ *
+ * @param subtask - The subtask to evaluate
+ * @param config - Swarm configuration with model preferences
+ * @returns Model identifier string
+ */
+export declare function selectWorkerModel(subtask: DecomposedSubtask & {
+    model?: string;
+}, config: SwarmConfig): string;
+//# sourceMappingURL=model-selection.d.ts.map

package/claude-plugin/dist/model-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-selection.d.ts","sourceRoot":"","sources":["../src/model-selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,iBAAiB,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/C,MAAM,EAAE,WAAW,GAClB,MAAM,CA4BR"}

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

@@ -0,0 +1,87 @@
+/**
+ * Observability Health - CLI health dashboard
+ *
+ * Shows what's being captured vs what's missing.
+ * Helps identify coverage gaps in observability instrumentation.
+ */
+export interface HookCoverageResult {
+    percentage: number;
+    wired: number;
+    total: number;
+    hooks: Array<{
+        name: string;
+        wired: boolean;
+        captures: number;
+    }>;
+}
+export interface EventCaptureStats {
+    days: number;
+    DECISION: number;
+    VIOLATION: number;
+    OUTCOME: number;
+    COMPACTION: number;
+}
+export interface SessionQualityResult {
+    totalSessions: number;
+    qualitySessions: number;
+    ghostSessions: number;
+    qualityPercentage: number;
+    warning: boolean;
+}
+export interface RegressionStatus {
+    detected: boolean;
+    count: number;
+    details?: string[];
+}
+export interface ObservabilityHealth {
+    hookCoverage: HookCoverageResult;
+    eventStats: EventCaptureStats;
+    sessionQuality: SessionQualityResult;
+    regressions: RegressionStatus;
+}
+export interface HookCoverageInput {
+    wiredHooks: readonly string[];
+    expectedHooks: readonly string[];
+    captureCounts?: Record<string, number>;
+}
+/**
+ * Calculate hook coverage - what % of expected hooks are wired
+ */
+export declare function calculateHookCoverage(input: HookCoverageInput): HookCoverageResult;
+/**
+ * Query event counts by type from database
+ */
+export declare function getEventCaptureStats(projectPath: string, options: {
+    days: number;
+}): Promise<EventCaptureStats>;
+export interface SessionQualityInput {
+    totalSessions: number;
+    qualitySessions: number;
+}
+/**
+ * Calculate session quality metrics
+ * Warning threshold: <50% quality sessions
+ */
+export declare function calculateSessionQuality(input: SessionQualityInput): SessionQualityResult;
+/**
+ * Query actual session quality from session files
+ * Quality session = has DECISION events (spawns, reviews, etc.)
+ */
+export declare function querySessionQuality(options: {
+    days: number;
+}): SessionQualityInput;
+/**
+ * Check for eval regressions
+ */
+export declare function checkRegressions(projectPath: string): Promise<RegressionStatus>;
+/**
+ * Format health dashboard with box-drawing characters
+ */
+export declare function formatHealthDashboard(health: ObservabilityHealth): string;
+/**
+ * Get full observability health report
+ */
+export declare function getObservabilityHealth(projectPath: string, options?: {
+    days?: number;
+}): Promise<ObservabilityHealth>;
+//# sourceMappingURL=observability-health.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observability-health.d.ts","sourceRoot":"","sources":["../src/observability-health.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,MAAM,WAAW,kBAAkB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,OAAO,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IACnC,YAAY,EAAE,kBAAkB,CAAC;IACjC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,cAAc,EAAE,oBAAoB,CAAC;IACrC,WAAW,EAAE,gBAAgB,CAAC;CAC9B;AAqDD,MAAM,WAAW,iBAAiB;IACjC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,iBAAiB,GACtB,kBAAkB,CAqBpB;AAMD;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GACvB,OAAO,CAAC,iBAAiB,CAAC,CAwC5B;AAMD,MAAM,WAAW,mBAAmB;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,mBAAmB,GACxB,oBAAoB,CActB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;CACb,GAAG,mBAAmB,CA+CtB;AAMD;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,WAAW,EAAE,MAAM,GACjB,OAAO,CAAC,gBAAgB,CAAC,CAmB3B;AAMD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CA8EzE;AAMD;;GAEG;AACH,wBAAsB,sBAAsB,CAC3C,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CA6B9B"}