sqlew 4.3.1 → 5.0.0

package/CHANGELOG.md

@@ -7,6 +7,74 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [5.0.0] - 2026-01-31
+
+### Added
+
+**🌐 SaaS Backend Support (sqlew.io)**
+
+- Connect to sqlew.io cloud service with `type = "cloud"` in config.toml
+- Team-shared decision database - all team members see the same architectural decisions
+- Multiple AI agents can work simultaneously without conflicts
+- No local database setup required - just add your API key
+- Connection Identity for seat-based billing with project-scoped hashing
+- Project name resolution with UUID caching for optimized API calls
+- X-Agent header for MCP client tracking in audit logs
+
+**📚 Environment-aware Help Examples**
+
+- Examples filtered by environment (SQLite shows numeric IDs, SaaS shows UUIDs)
+- `target_type` attribute in TOML: `sqlite`, `cloud`, or `all`
+- Automatic filtering in help `query-action`, example `get`, `search`, `list-all` actions
+
+**🌳 Git Worktree Support**
+
+- Automatic worktree detection for multi-branch development
+- Config inheritance from main repository
+- Independent session cache per worktree
+- Seamless context sharing across worktrees
+
+**🔌 Plugin-first Architecture**
+
+- Skills/Hooks/Agents moved to separate `sqlew-plugin` repository
+- Global Rules auto-created at `~/.claude/rules/sqlew/` on MCP startup
+- Per-project Skills/Hooks installation removed (use plugin marketplace instead)
+- Simplified setup: just install the plugin and connect to sqlew.io
+
+**Queue Tool for Hook Queue Management**
+
+- New `queue` MCP tool to manage `.sqlew/queue/pending.json`
+- Actions: `list` (view pending items), `remove` (delete by index), `clear` (remove all)
+- Lock mechanism to prevent race conditions with QueueWatcher
+- Help documentation in `src/help-data/queue.toml`
+- Queue monitoring rule in `~/.claude/rules/sqlew/queue-monitoring.md`
+
+**TOML-based Help System**
+
+- Help documentation now stored in `src/help-data/*.toml` (version-controlled, human-editable)
+- `HelpSystemLoader` for startup-time loading with in-memory caching (O(1) lookups)
+- 15 TOML files: 8 tool files (including queue) + 6 use case workflows + 1 schema file
+
+### Changed
+
+- **MCP tools: 6 → 7** (queue tool added)
+- `help`, `example`, `use_case` tools now load from TOML files instead of database
+- Database schema reduced: 18 tables (7 master + 11 transaction)
+- Table prefix renamed: `v4_` → `m_/t_` (master/transaction convention)
+- Multi-database backend now includes Cloud option (SQLite/PostgreSQL/MySQL/Cloud)
+- Constraint ID now supports both `number` (SQLite) and `string` UUID (SaaS)
+- `constraint_id` parameter renamed to `id` (backward compatibility maintained via alias)
+- Lazy initialization of agent name after MCP handshake completion
+
+### Removed
+
+- **Per-project Skills/Hooks installation** - Use sqlew-plugin from marketplace instead
+- **7 help database tables**: m_help_tools, m_help_actions, m_help_use_case_cats, t_help_action_params, t_help_action_examples, t_help_use_cases, t_help_action_sequences
+- `help-queries.ts` (replaced by HelpSystemLoader)
+- Task and file management tables (deprecated in v4.3.0)
+
+---
+
 ## [4.3.1] - 2026-01-06
 
 ### Added

package/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2025 sin5ddd
+   Copyright 2025 sqlew-io
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/NOTICE

@@ -1,7 +1,7 @@
 sqlew
-Copyright 2025 sin5ddd
+Copyright 2025 sqlew-io
 
-This product includes software developed by sin5ddd.
+This product includes software developed by sqlew-io.
 
 Licensed under the Apache License, Version 2.0.
 

package/README.md

@@ -1,4 +1,5 @@
 # sqlew
+
 ![sqlew_logo](assets/sqlew-logo.png)
 
 [![npm version](https://img.shields.io/npm/v/sqlew.svg)](https://www.npmjs.com/package/sqlew)
@@ -8,41 +9,79 @@
 
 ## 🚀 Quick Start
 
-### 1. Install globally (Recommended)
+### 1. Install MCP Server
 
 ```bash
 npm install -g sqlew
 ```
 
-### 2. Add to your MCP config
+### 2. Install Plugin (Recommended)
 
-Add to `.mcp.json` in your project root:
+In Claude Code, run the following commands:
 
-```json
-{
-  "mcpServers": {
-    "sqlew": {
-      "command": "sqlew"
-    }
-  }
-}
+```bash
+# 1. Add the marketplace
+/plugin marketplace add sqlew-io/sqlew-plugin
+
+# 2. Install the plugin (user-level recommended)
+/plugin install sqlew-plugin
+
+# 3. Restart Claude Code to apply changes
 ```
 
-### 3. Initialize project
+**That's it!** The plugin automatically sets up everything:
+
+- ✅ MCP server config (`.mcp.json`)
+- ✅ Claude Code Skills (Plan Mode guidance)
+- ✅ Claude Code Hooks (automatic decision capture)
+
+> **Note:** Global Rules are automatically created at `~/.claude/rules/sqlew/` when the MCP server starts.
+
+### 3. Connect to sqlew.io (For Teams) 🌐
+
+**NEW in v5.0.0**: Connect to the cloud for team-shared decisions!
+
+**Step 1: Get your API key** (one-time setup)
+
+Visit [sqlew.io](https://sqlew.io) and save your API key:
 
 ```bash
-sqlew --init
+# ~/.sqlew.env (shared across all projects)
+SQLEW_API_KEY=your-api-key
+```
+
+**Step 2: Configure each project**
+
+```toml
+# .sqlew/config.toml (per-project)
+[database]
+type = "cloud"
+
+[project]
+name = "your-project-name"
 ```
 
-This one-shot command sets up:
-- Claude Code Skills
-- CLAUDE.md integration hints
-- Plan-to-ADR hooks
-- .gitignore entries
+> **Note:** Each project needs its own `.sqlew/config.toml` to specify the project name.
+
+**Benefits:**
+- 👥 **Team sharing** - All team members share the same decision database
+- 🌳 **Git worktree ready** - Works seamlessly with multiple branches
+- ⚡ **Zero setup** - No local database required
+
+### Alternative: Local Database (Offline)
+
+For offline or single-developer use, **no setup required**:
+
+- Database (`.sqlew/sqlew.db`) is auto-created on first MCP server start
+- Config file (`.sqlew/config.toml`) is auto-generated with detected project name
+- Global rules (`~/.claude/rules/sqlew/`) are auto-installed
+
+Just start using Claude Code - everything initializes automatically!
 
 ### 4. Just use Plan Mode!
 
 **That's it!** Now every time you:
+
 1. Create a plan in Claude Code
 2. Get user approval (ExitPlanMode)
 
@@ -67,15 +106,18 @@ For manual queries and explicit decision recording:
 **sqlew** is a Model Context Protocol (MCP) server that brings ADR (Architecture Decision Record) capabilities to AI agents through a shared SQL-backed repository.
 
 ### The Problem: AI Agents Lack Decision Memory
+
 Every AI session starts with zero context. Agents must re-learn architectural decisions, can reintroduce previously rejected patterns, and have no systematic way to understand WHY past choices were made.
 
 Traditional ADR approaches use Markdown files scattered across repositories. While human-readable, this format creates challenges for AI agents:
+
 - **No structured querying** – AI must read entire files to find relevant decisions
 - **Context explosion** – Token costs grow linearly with decision history
 - **No duplicate detection** – AI cannot easily identify similar or conflicting decisions
 - **Poor discoverability** – Finding related decisions requires full-text search across many files
 
-### *sqlew* brings structured ADR to AI agents
+### _sqlew_ brings structured ADR to AI agents
+
 sqlew transforms ADR from static documentation into a **queryable, AI-native decision database**:
 
 - **Structured records** – Decisions stored as relational data with metadata, tags, and relationships
@@ -84,33 +126,49 @@ sqlew transforms ADR from static documentation into a **queryable, AI-native dec
 - **Constraint tracking** – Architectural rules and principles as first-class entities
 - **Auto-capture** – Claude Code Hooks automatically record decisions from Plan Mode
 
-> *This software does not send any data to external networks. We NEVER collect any data or usage statistics. Please use it with complete security.*
+> _This software does not send any data to external networks. We NEVER collect any data or usage statistics. Please use it with complete security._
 
 ## Why sqlew?
 
 AI agents automatically accumulate project knowledge through Plan Mode. Decisions are stored in SQL for efficient querying.
 
+### 🌐 Team Development Made Easy (NEW in v5.0.0)
+
+- **Shared decision database** - All team members see the same architectural decisions
+- **Multiple AI agents** - Work simultaneously without conflicts
+- **No local setup** - Just add your API key and start
+
+### 🌳 Perfect for Git Worktree Workflows
+
+- **Automatic worktree detection** - Each worktree shares the same context
+- **Config inheritance** - Main repository settings apply everywhere
+- **Independent sessions** - Each worktree has its own cache
+
 **Perfect for:**
+
 - 🏢 Large-scale projects with many architectural decisions
 - 🔧 Long-term maintenance where context must persist across sessions
-- 👥 Team environments where multiple AI agents share knowledge
+- 👥 **Team environments** where multiple AI agents share knowledge
+- 🌳 **Git worktree** workflows with multiple concurrent branches
 
 **Key benefits:**
+
 - ⚡ **60-75% token reduction** vs reading Markdown ADRs
 - 🔍 **Millisecond queries** (2-50ms) even with thousands of decisions
 - 🛡️ **Duplicate prevention** via similarity detection
 - 📚 **Persistent memory** across all AI sessions
+- 👥 **Team sync** via sqlew.io cloud backend
 
 → See [ADR Concepts](docs/ADR_CONCEPTS.md) for detailed architecture.
 
 ---
 
-**Technical Features**: 6 MCP tools (3 core: decision, constraint, suggest + 3 utility: help, example, use_case), three-tier similarity detection (0-100 point scoring), ACID transaction support, multi-database backend (SQLite/PostgreSQL/MySQL), metadata-driven organization with layers and tags
-
+**Technical Features**: 7 MCP tools (3 core: decision, constraint, suggest + 4 utility: help, example, use_case, queue), three-tier similarity detection (0-100 point scoring), ACID transaction support, multi-database backend (SQLite/PostgreSQL/MySQL/Cloud), metadata-driven organization with layers and tags
 
 ## Installation
 
 ### Requirements
+
 - Node.js 20.0.0 or higher
 - npm or npx
 
@@ -126,11 +184,11 @@ Then add to `.mcp.json` in your project root:
 
 ```json
 {
-  "mcpServers": {
-    "sqlew": {
-      "command": "sqlew"
+    "mcpServers": {
+        "sqlew": {
+            "command": "sqlew"
+        }
     }
-  }
 }
 ```
 
@@ -149,11 +207,11 @@ Each project maintains its own context database in `.sqlew/sqlew.db`.
 
 sqlew supports multiple database backends:
 
-| Database | Use Case | Status |
-|----------|----------|--------|
-| **SQLite** | Personal/small projects | ✅ Default |
+| Database                     | Use Case                 | Status       |
+| ---------------------------- | ------------------------ | ------------ |
+| **SQLite**                   | Personal/small projects  | ✅ Default   |
 | **MySQL 8.0+ / MariaDB 10+** | Production, team sharing | ✅ Supported |
-| **PostgreSQL 12+** | Production, team sharing | ✅ Supported |
+| **PostgreSQL 12+**           | Production, team sharing | ✅ Supported |
 
 Configuration is managed via `.sqlew/config.toml` file and CLI arguments.
 
@@ -168,6 +226,7 @@ And `action: "use_case"` shows how to use the tool in a real-world scenario.
 ### On-Demand Documentation
 
 All tools support:
+
 - `action: "help"` - Parameter reference and descriptions
 - `action: "example"` - Usage scenarios and examples
 - `action: "use_case"` - Real-world usage examples
@@ -177,33 +236,43 @@ All tools support:
 **Essential Guides:**
 
 **Advanced Features:**
+
 - [Hooks Guide](docs/HOOKS_GUIDE.md) - Claude Code Hooks integration
 - [Cross Database](docs/CROSS_DATABASE.md) - Multi-database support
 
 **Reference:**
+
 - [Configuration](docs/CONFIGURATION.md) - Config file setup, all options
 
 ### Advanced Usage
 
 - [Configuration Guide](docs/CONFIGURATION.md) - TOML config file setup
 - [CLI Mode Overview](docs/cli/README.md) - Database migration, export/import commands
-- [Migration Guides](docs/MIGRATION_v2.md) - Version upgrade guides
+
+### Upgrade Guides
+
+- **[Upgrade from v4 to v5](docs/MIGRATION_CLEANUP_GUIDE.md)** - Cleanup legacy files after plugin migration
+- **[Migrating Local Data to SaaS](docs/MIGRATION_TO_SAAS.md)** - Export local v3.x/v4.x data to sqlew.io cloud
+- [Migration from v2](docs/MIGRATION_v2.md) - Version upgrade guides
 
 ## Use Cases
 
 ### ADR-Driven Development with AI
+
 - **Architecture Evolution** – Document major architectural decisions with full context and alternatives
 - **Pattern Standardization** – Establish coding patterns as constraints, enforce via AI code generation
 - **Technical Debt Tracking** – Record temporary decisions with deprecation paths and future plans
 - **Onboarding Acceleration** – New AI sessions instantly understand architectural history
 
 ### Cross-Session AI Workflows
+
 - **Multi-Session Projects** – AI maintains context across days/weeks without re-reading documentation
 - **Multi-Agent Coordination** – Multiple AI agents share architectural understanding through ADR database
 - **Breaking Change Management** – Document API changes, deprecations, and migration paths systematically
 - **Refactoring Guidance** – AI references past decisions to maintain architectural consistency during refactors
 
 ### Real-World Examples
+
 ```bash
 # Document an architectural decision with alternatives
 /sqlew record we use PostgreSQL over MongoDB. MongoDB was rejected due to lack of ACID transactions for our financial data requirements.
@@ -218,7 +287,6 @@ All tools support:
 /sqlew plan implementing the PostgreSQL connection pool with pgBouncer
 ```
 
-
 ## Performance
 
 - **Query speed**: 2-50ms
@@ -228,17 +296,19 @@ All tools support:
 
 ## Support
 
-Support development via [GitHub Sponsors](https://github.com/sponsors/sin5ddd) - One-time or monthly options available.
+Support development via [GitHub Sponsors](https://github.com/sponsors/sqlew-io) - One-time or monthly options available.
 
 ## Version
 
-Current version: **4.3.1**
+Current version: **5.0.0**
 See [CHANGELOG.md](CHANGELOG.md) for release history.
 
-**What's New in v4.3.1:**
-- **`.claude/rules/` Integration** - Safer installation without modifying CLAUDE.md
-- **Incremental gitignore** - Missing entries added even if sqlew section exists
-- **Code Quality** - DRY improvements, obsolete code cleanup
+**What's New in v5.0.0:**
+
+- 🌐 **SaaS Backend** - Connect to [sqlew.io](https://sqlew.io) for team-shared decisions
+- 🌳 **Git Worktree Support** - Seamless multi-branch development
+- 🔌 **Plugin-first Architecture** - Simplified setup via sqlew-plugin
+- 🔧 **Queue Tool** - Hook queue management (list, remove, clear)
 
 See [docs/HOOKS_GUIDE.md](docs/HOOKS_GUIDE.md) for Claude Code Hooks details.
 
@@ -249,19 +319,19 @@ Apache License 2.0 - Free for commercial and personal use. See [LICENSE](LICENSE
 ## Links
 
 - [npm package](https://www.npmjs.com/package/sqlew)
-- [GitHub repository](https://github.com/sin5ddd/mcp-sqlew)
+- [GitHub repository](https://github.com/sqlew-io/sqlew)
 - [Model Context Protocol](https://modelcontextprotocol.io/)
 
 ## Support & Documentation
 
-- Issues: [GitHub Issues](https://github.com/sin5ddd/mcp-sqlew/issues)
+- Issues: [GitHub Issues](https://github.com/sqlew-io/sqlew/issues)
 - Docs: [docs/](docs/) directory
 
 ## Acknowledgments
 
 Built with [Model Context Protocol SDK](https://github.com/modelcontextprotocol/sdk), [better-sqlite3](https://github.com/WiseLibs/better-sqlite3), and TypeScript.
 
-**Author**: sin5ddd
+**Author**: sqlew-io
 
 ---
 

package/assets/claude-md-snippets/plan-mode-integration.md

@@ -1,5 +1,38 @@
 ## Plan Mode Integration
 
+### REQUIRED: Suggest Search BEFORE Planning
+
+**CRITICAL**: Before writing any plan, you MUST search for related context.
+
+**Step 1**: Extract keywords from the user's task (e.g., migration, auth, database)
+
+**Step 2**: Run suggest search:
+```
+suggest { action: "by_context", key: "<keyword>", tags: ["<relevant-tags>"] }
+suggest { action: "by_context", target: "constraint", text: "<topic>" }
+```
+
+**Step 3**: Include results in plan (MANDATORY section):
+```markdown
+## Related Context (from sqlew)
+
+### Past Decisions
+| Key | Value | Score |
+|-----|-------|-------|
+| path/to/decision | description | 85 |
+
+> If empty: "No related decisions found for: <keywords>"
+
+### Applicable Constraints
+- **[category]**: constraint text (Priority: high)
+
+> If empty: "No constraints found for: <keywords>"
+```
+
+**FAILURE TO INCLUDE "Related Context" SECTION = INVALID PLAN**
+
+---
+
 ### REQUIRED: Decision & Constraint Recording
 
 **When writing plans, you MUST include the following sections:**
@@ -48,3 +81,24 @@ If you've run `sqlew --hooks`, sqlew integration is **fully automatic**:
 
 **Final Plan Phase:**
 - `/sqlew record <decision>` - record key architectural decisions
+
+---
+
+### Failed Queue Check (IMPORTANT)
+
+**At the start of plan mode**, check if `.sqlew/queue/failed.json` exists:
+
+```bash
+# Check failed queue status
+queue { action: "list" }  # Shows both pending and failed items
+```
+
+**If failed items exist:**
+
+1. **Review each failed item** - Common failure: HighSimilarity (60%+) means the item is similar to an existing decision
+2. **Resolution options:**
+   - **If truly duplicate**: Delete the failed queue file or use `queue { action: "clear" }` with `target: "failed"`
+   - **If different intent**: Use a more specific key and re-register manually via `/sqlew record <decision>`
+3. **After resolving**: Delete or empty the failed queue file
+
+**Why this happens**: Items that fail processing (e.g., high similarity to existing decisions) are moved to `failed.json` instead of being retried indefinitely. This prevents infinite retry loops.

package/assets/claude-md-snippets/queue-monitoring.md

@@ -0,0 +1,84 @@
+## Queue Monitoring After Plan Mode
+
+### When to Check
+
+After ExitPlanMode or when Plan-to-ADR processing completes, check if there are unprocessed items in the queue.
+
+**Queue file locations:**
+- Pending: `.sqlew/queue/pending.json`
+- Failed: `.sqlew/queue/failed.json`
+
+### How to Check
+
+Use the `queue` MCP tool to check the queue status:
+
+```
+queue { action: "list" }
+```
+
+The response includes:
+- `count`: Number of pending items
+- `failedCount`: Number of failed items (if any)
+
+### Failed Queue (v5.0.1+)
+
+Items that fail processing (e.g., HighSimilarity errors) are automatically moved to `failed.json` instead of being retried indefinitely.
+
+**Why items fail:**
+- **HighSimilarity (60%+)**: Item is too similar to an existing decision
+- **Validation errors**: Invalid layer, category, or other data issues
+
+**Resolution:**
+1. Check `failedItems` in `queue { action: "list" }` response
+2. For duplicates: Clear with `queue { action: "clear", target: "failed" }`
+3. For different intent: Re-register manually with a more specific key via `/sqlew record <decision>`
+
+### Queue Tool Actions
+
+| Action | Description | Example |
+|--------|-------------|---------|
+| `list` | Show pending and failed items | `queue { action: "list" }` |
+| `remove` | Remove specific pending item | `queue { action: "remove", index: 0 }` |
+| `clear` | Clear pending queue (default) | `queue { action: "clear" }` |
+| `clear` | Clear failed queue | `queue { action: "clear", target: "failed" }` |
+| `clear` | Clear both queues | `queue { action: "clear", target: "all" }` |
+
+### Queue File Formats
+
+**pending.json:**
+```json
+{
+  "items": [
+    {
+      "type": "decision",
+      "action": "create",
+      "timestamp": "2026-01-13T00:00:00.000Z",
+      "data": {
+        "key": "path/to/decision",
+        "value": "description",
+        "status": "draft",
+        "layer": "infrastructure",
+        "tags": ["plan", "auto-extracted", "..."]
+      }
+    }
+  ]
+}
+```
+
+**failed.json:**
+```json
+{
+  "items": [
+    {
+      "item": {
+        "type": "decision",
+        "action": "create",
+        "timestamp": "2026-01-24T...",
+        "data": { "key": "...", "value": "..." }
+      },
+      "error": "HighSimilarity: 65% match with existing decision 'path/to/existing'",
+      "failedAt": "2026-01-24T..."
+    }
+  ]
+}
+```

package/dist/backend/backend-factory.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Backend Factory
+ *
+ * Creates and manages backend instances based on configuration.
+ * Supports LocalBackend (direct DB) and SaaS backend (submodule).
+ */
+import type { ToolBackend } from './types.js';
+import type { SqlewConfig, CloudConfig } from '../config/types.js';
+/**
+ * Check if the configuration specifies cloud mode
+ */
+export declare function isCloudMode(config: SqlewConfig): boolean;
+/**
+ * Load cloud configuration from global ~/.sqlew.env or environment variables
+ *
+ * Flow:
+ * 1. Load API key from ~/.sqlew.env
+ * 2. Load project name from .sqlew/config.toml
+ * 3. Check cached project ID in ~/.sqlew.env
+ * 4. If not cached, resolve via /api/v1/project/resolve and cache
+ *
+ * @param projectRoot - Project root directory (for ConnectionIdentity)
+ * @returns CloudConfig or null if not configured
+ */
+export declare function loadCloudConfig(projectRoot?: string): Promise<CloudConfig | null>;
+/**
+ * Validate cloud configuration
+ */
+export declare function validateCloudConfig(config: CloudConfig | null): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create a backend instance based on configuration
+ *
+ * @param config - sqlew configuration
+ * @param projectRoot - Project root directory
+ * @returns Backend instance
+ */
+export declare function createBackend(config: SqlewConfig, projectRoot?: string): Promise<ToolBackend>;
+/**
+ * Initialize the global backend instance
+ *
+ * @param config - sqlew configuration
+ * @param projectRoot - Project root directory
+ * @returns Backend instance
+ */
+export declare function initializeBackend(config: SqlewConfig, projectRoot?: string): Promise<ToolBackend>;
+/**
+ * Get the current backend instance
+ *
+ * @returns Backend instance (creates LocalBackend if not initialized)
+ */
+export declare function getBackend(): ToolBackend;
+/**
+ * Check if backend is initialized
+ */
+export declare function isBackendInitialized(): boolean;
+/**
+ * Get current backend type
+ */
+export declare function getBackendType(): 'local' | 'saas' | null;
+/**
+ * Reset backend state (for testing)
+ */
+export declare function resetBackend(): Promise<void>;
+//# sourceMappingURL=backend-factory.d.ts.map

package/dist/backend/backend-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-factory.d.ts","sourceRoot":"","sources":["../../src/backend/backend-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAsBnE;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAExD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAwCvF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAapG;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAwBnG;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAcvG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,WAAW,CAMxC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,GAAG,MAAM,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAMlD"}