@paths.design/caws-cli 7.0.0 → 7.0.2

package/dist/minimal-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=minimal-cli.d.ts.map

package/dist/minimal-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal-cli.d.ts","sourceRoot":"","sources":["../src/minimal-cli.js"],"names":[],"mappings":""}

package/dist/policy/PolicyManager.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Policy Manager - Handles policy loading with intelligent caching
+ *
+ * Features:
+ * - TTL-based caching for performance
+ * - Graceful fallback to defaults when policy.yaml missing
+ * - Cache inspection and management API
+ * - Waiver validation and delta application
+ */
+export class PolicyManager {
+    constructor(options?: {});
+    enableCaching: any;
+    cacheTTL: any;
+    policyCache: Map<any, any>;
+    /**
+     * Load CAWS policy from policy.yaml with caching
+     *
+     * @param {string} projectRoot - Project root directory
+     * @param {Object} options - Loading options
+     * @param {boolean} options.useCache - Use cache if available (default: true)
+     * @param {number} options.cacheTTL - Cache TTL override in milliseconds
+     * @returns {Promise<Object>} Policy object
+     */
+    loadPolicy(projectRoot: string, options?: {
+        useCache: boolean;
+        cacheTTL: number;
+    }): Promise<any>;
+    /**
+     * Load a waiver document by ID
+     *
+     * @param {string} waiverId - Waiver ID (e.g., WV-0001)
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object|null>} Waiver document or null if not found
+     */
+    loadWaiver(waiverId: string, projectRoot: string): Promise<any | null>;
+    /**
+     * Check if a waiver is currently valid
+     *
+     * @param {Object} waiver - Waiver document
+     * @returns {boolean} True if waiver is valid and active
+     */
+    isWaiverValid(waiver: any): boolean;
+    /**
+     * Apply waivers to baseline budget
+     *
+     * @param {Object} baseline - Baseline budget from policy
+     * @param {string[]} waiverIds - Array of waiver IDs to apply
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object>} Effective budget with waivers applied
+     */
+    applyWaivers(baseline: any, waiverIds: string[], projectRoot: string): Promise<any>;
+    /**
+     * Validate policy structure
+     *
+     * @param {Object} policy - Policy to validate
+     * @throws {Error} If policy is invalid
+     */
+    validatePolicy(policy: any): void;
+    /**
+     * Get default CAWS policy
+     *
+     * Returns sensible defaults when policy.yaml doesn't exist.
+     *
+     * @returns {Object} Default policy configuration
+     */
+    getDefaultPolicy(): any;
+    /**
+     * Clear policy cache
+     *
+     * @param {string} [projectRoot] - Specific project to clear, or all if omitted
+     */
+    clearCache(projectRoot?: string): void;
+    /**
+     * Get cache status for a project
+     *
+     * @param {string} projectRoot - Project root directory
+     * @returns {Object} Cache status information
+     */
+    getCacheStatus(projectRoot: string): any;
+    /**
+     * Reload policy from disk (bypassing cache)
+     *
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object>} Fresh policy
+     */
+    reloadPolicy(projectRoot: string): Promise<any>;
+    /**
+     * Get all cached projects
+     *
+     * @returns {string[]} Array of project roots with cached policies
+     */
+    getCachedProjects(): string[];
+    /**
+     * Get cache statistics
+     *
+     * @returns {Object} Cache statistics
+     */
+    getCacheStats(): any;
+}
+export const defaultPolicyManager: PolicyManager;
+export declare function loadPolicy(projectRoot: any, options: any): Promise<any>;
+export declare function clearCache(projectRoot: any): void;
+export declare function getCacheStatus(projectRoot: any): any;
+//# sourceMappingURL=PolicyManager.d.ts.map

package/dist/policy/PolicyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolicyManager.d.ts","sourceRoot":"","sources":["../../src/policy/PolicyManager.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH;IACE,0BAIC;IAHC,mBAAkD;IAClD,cAA0C;IAC1C,2BAA4B;IAG9B;;;;;;;;OAQG;IACH,wBANW,MAAM,YAEd;QAAyB,QAAQ,EAAzB,OAAO;QACS,QAAQ,EAAxB,MAAM;KACd,GAAU,OAAO,KAAQ,CAuE3B;IAED;;;;;;OAMG;IACH,qBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAchC;IAED;;;;;OAKG;IACH,4BAFa,OAAO,CA2BnB;IAED;;;;;;;OAOG;IACH,uCAJW,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,KAAQ,CA2B3B;IAED;;;;;OAKG;IACH,kCA8BC;IAED;;;;;;OAMG;IACH,wBAoDC;IAED;;;;OAIG;IACH,yBAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,4BAHW,MAAM,OAmBhB;IAED;;;;;OAKG;IACH,0BAHW,MAAM,GACJ,OAAO,KAAQ,CAK3B;IAED;;;;OAIG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,qBA2BC;CACF;AAGD,iDAAiD;AAOnC,iFAA+E;AAC/E,2DAA6D;AACzD,8DAAiE"}

package/dist/scaffold/cursor-hooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Scaffold Cursor hooks for a CAWS project
+ * @param {string} projectDir - Project directory path
+ * @param {string[]} levels - Hook levels to enable
+ */
+export function scaffoldCursorHooks(projectDir: string, levels?: string[]): Promise<void>;
+//# sourceMappingURL=cursor-hooks.d.ts.map

package/dist/scaffold/cursor-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/cursor-hooks.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,gDAHW,MAAM,WACN,MAAM,EAAE,iBAqJlB"}

package/dist/scaffold/cursor-hooks.js

@@ -9,7 +9,7 @@ const path = require('path');
 const chalk = require('chalk');
 
 // Import detection utilities
-const { detectCAWSSetup } = require('../utils/detection');
+const { detectCAWSSetup, findPackageRoot } = require('../utils/detection');
 
 /**
  * Scaffold Cursor hooks for a CAWS project
@@ -28,9 +28,17 @@ async function scaffoldCursorHooks(projectDir, levels = ['safety', 'quality', 's
 
     // Determine template directory - prefer bundled templates
     const setup = detectCAWSSetup(projectDir);
-    const bundledTemplateDir = path.join(__dirname, '../../templates');
+    
+    // Find package root using shared utility
+    const packageRoot = findPackageRoot(__dirname);
+    
+    // Try templates relative to package root first (works in both dev and global install)
+    const bundledTemplateDir = path.join(packageRoot, 'templates');
+    const fallbackTemplateDir = path.join(__dirname, '../../templates');
     const templateDir = fs.existsSync(bundledTemplateDir)
       ? bundledTemplateDir
+      : fs.existsSync(fallbackTemplateDir)
+      ? fallbackTemplateDir
       : setup.templateDir || path.resolve(__dirname, '../templates');
 
     const cursorTemplateDir = path.join(templateDir, '.cursor');

package/dist/scaffold/git-hooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scaffold git hooks for CAWS provenance tracking
+ * @param {string} projectDir - Project directory path
+ * @param {Object} options - Hook options
+ */
+export function scaffoldGitHooks(projectDir: string, options?: any): Promise<{
+    added: number;
+    skipped: number;
+}>;
+/**
+ * Remove CAWS git hooks
+ * @param {string} projectDir - Project directory path
+ */
+export function removeGitHooks(projectDir: string): Promise<void>;
+/**
+ * Check git hooks status
+ * @param {string} projectDir - Project directory path
+ */
+export function checkGitHooksStatus(projectDir: string): Promise<void>;
+//# sourceMappingURL=git-hooks.d.ts.map

package/dist/scaffold/git-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/git-hooks.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM;;;GAwGhB;AAwND;;;GAGG;AACH,2CAFW,MAAM,iBAkChB;AAED;;;GAGG;AACH,gDAFW,MAAM,iBAgDhB"}

package/dist/scaffold/git-hooks.js

@@ -364,12 +364,71 @@ fi
 # Run full validation suite
 if command -v caws >/dev/null 2>&1; then
   echo "📋 Running comprehensive CAWS validation..."
-  if caws validate --quiet; then
+  
+  # Run validation and capture output
+  VALIDATION_OUTPUT=$(caws validate 2>&1)
+  VALIDATION_EXIT=$?
+  
+  if [ $VALIDATION_EXIT -eq 0 ]; then
     echo "✅ CAWS validation passed"
   else
     echo "❌ CAWS validation failed"
-    echo "💡 Fix issues locally, then push again"
-    echo "💡 You can commit fixes with: git commit --no-verify"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Validation Errors:"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "$VALIDATION_OUTPUT" | grep -E "(❌|error|Error|Missing|required)" || echo "$VALIDATION_OUTPUT"
+    echo ""
+    
+    # Check for contract-related errors
+    if echo "$VALIDATION_OUTPUT" | grep -qi "contract"; then
+      echo "💡 Contract Requirements:"
+      echo "   • Tier 1 & 2 changes require at least one contract"
+      echo "   • For infrastructure/setup work, use 'chore' mode or add a minimal contract:"
+      echo ""
+      echo "   Example minimal contract (.caws/working-spec.yaml):"
+      echo "   contracts:"
+      echo "     - type: 'project_setup'"
+      echo "       path: '.caws/working-spec.yaml'"
+      echo "       description: 'Project-level CAWS configuration'"
+      echo ""
+      echo "   Or change mode to 'chore' for maintenance work:"
+      echo "   mode: chore"
+      echo ""
+    fi
+    
+    # Check for active waivers
+    echo "🔍 Checking for active waivers..."
+    if command -v caws >/dev/null 2>&1 && caws waivers list --status=active --format=count 2>/dev/null | grep -q "[1-9]"; then
+      ACTIVE_WAIVERS=$(caws waivers list --status=active 2>/dev/null)
+      echo "⚠️  Active waivers found:"
+      echo "$ACTIVE_WAIVERS" | head -5
+      echo ""
+      echo "💡 Note: Waivers may not cover all validation failures"
+      echo "   Review waiver coverage: caws waivers list --status=active"
+    else
+      echo "   No active waivers found"
+      echo ""
+      echo "💡 If this is infrastructure/setup work, you can create a waiver:"
+      echo "   caws waivers create \\"
+      echo "     --title='Initial CAWS setup' \\"
+      echo "     --reason=infrastructure_limitation \\"
+      echo "     --gates=contracts \\"
+      echo "     --expires-at='2024-12-31T23:59:59Z' \\"
+      echo "     --approved-by='@your-team' \\"
+      echo "     --impact-level=low \\"
+      echo "     --mitigation-plan='Contracts will be added as features are developed'"
+    fi
+    
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "Next Steps:"
+    echo "   1. Review errors above"
+    echo "   2. Fix issues in .caws/working-spec.yaml"
+    echo "   3. Run: caws validate (to verify fixes)"
+    echo "   4. Commit fixes: git commit --no-verify (allowed)"
+    echo "   5. Push again: git push"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
     exit 1
   fi
 fi

package/dist/scaffold/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scaffold existing project with CAWS components
+ * @param {Object} options - Scaffold options
+ */
+export function scaffoldProject(options: any): Promise<void>;
+/**
+ * Scaffold IDE integrations for comprehensive CAWS development experience
+ * @param {string} targetDir - Target directory for scaffolding
+ * @param {Object} options - Scaffold options
+ */
+export function scaffoldIDEIntegrations(targetDir: string, options: any): Promise<{
+    added: number;
+    skipped: number;
+}>;
+/**
+ * Set dependencies for scaffold module
+ * @param {Object} deps - Dependencies object
+ */
+export function setScaffoldDependencies(deps: any): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/scaffold/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,6DA6VC;AAhfD;;;;GAIG;AACH,mDAHW,MAAM;;;GA8HhB;AAMD;;;GAGG;AACH,yDAGC"}

package/dist/scaffold/index.js

@@ -9,7 +9,7 @@ const path = require('path');
 const chalk = require('chalk');
 
 // Import detection utilities
-const { detectCAWSSetup } = require('../utils/detection');
+const { detectCAWSSetup, findPackageRoot } = require('../utils/detection');
 const { detectsPublishing } = require('../utils/project-analysis');
 
 // Import git hooks scaffolding
@@ -23,8 +23,33 @@ const CLI_VERSION = require('../../package.json').version;
  * @param {string} targetDir - Target directory for scaffolding
  * @param {Object} options - Scaffold options
  */
+/**
+ * Find the template directory using robust path resolution
+ * Works in both development and global install scenarios
+ * @returns {string|null} Template directory path or null
+ */
+function findTemplateDir() {
+  // Find package root using shared utility
+  const packageRoot = findPackageRoot(__dirname);
+  
+  // Try templates relative to package root first (works in both dev and global install)
+  const possiblePaths = [
+    path.join(packageRoot, 'templates'),
+    path.resolve(__dirname, '../../templates'), // Dev fallback
+    path.resolve(__dirname, '../templates'), // Legacy fallback
+  ];
+  
+  for (const testPath of possiblePaths) {
+    if (fs.existsSync(testPath)) {
+      return testPath;
+    }
+  }
+  
+  return null;
+}
+
 async function scaffoldIDEIntegrations(targetDir, options) {
-  const templateDir = path.join(__dirname, '../../templates');
+  const templateDir = findTemplateDir() || path.join(__dirname, '../../templates');
 
   console.log(chalk.cyan('🎨 Setting up IDE integrations...'));
 
@@ -192,19 +217,24 @@ async function scaffoldProject(options) {
       setup.templateDir = cawsSetup.templateDir;
       setup.hasTemplateDir = true;
     } else if (!setup.templateDir) {
-      // Try to find template directory using absolute paths that work in CI
+      // Try to find template directory using robust path resolution
       const possiblePaths = [
-        // 1. Bundled templates in CLI package (for global installs) - CHECK THIS FIRST!
+        // 1. Use the helper function to find templates (works in dev and global install)
+        findTemplateDir(),
+        // 2. Bundled templates relative to package root
+        path.join(findPackageRoot(__dirname), 'templates'),
+        // 3. Legacy fallback paths
         path.join(__dirname, '../../templates'),
-        // 2. CI paths
+        path.join(__dirname, '../templates'),
+        // 4. CI paths
         '/home/runner/work/coding-agent-working-standard/coding-agent-working-standard/packages/caws-template',
         '/workspace/packages/caws-template',
         '/caws/packages/caws-template',
-        // 3. Monorepo relative paths
+        // 5. Monorepo relative paths
         path.resolve(process.cwd(), '../../../packages/caws-template'),
         path.resolve(process.cwd(), '../../packages/caws-template'),
         path.resolve(process.cwd(), '../packages/caws-template'),
-      ];
+      ].filter(Boolean); // Remove null values
 
       for (const testPath of possiblePaths) {
         if (fs.existsSync(testPath)) {
@@ -567,10 +597,22 @@ async function scaffoldProject(options) {
             console.warn(chalk.yellow(`⚠️  Failed to add ${enhancement.name}:`), copyError.message);
           }
         } else {
-          // If source doesn't exist in template, create the directory structure
+          // If source doesn't exist in template, check if it should be a file or directory
           try {
-            await fs.ensureDir(destPath);
-            console.log(chalk.green(`✅ Created ${enhancement.description}`));
+            // Check if the enhancement name looks like a file (has extension)
+            const hasExtension = path.extname(enhancement.name).length > 0;
+            
+            if (hasExtension) {
+              // Create an empty file for file-like enhancements
+              await fs.ensureDir(path.dirname(destPath));
+              await fs.writeFile(destPath, '');
+              console.log(chalk.yellow(`⚠️  Created empty ${enhancement.description} (template not found)`));
+              console.log(chalk.gray(`   Template expected at: ${sourcePath}`));
+            } else {
+              // Create directory for directory-like enhancements
+              await fs.ensureDir(destPath);
+              console.log(chalk.green(`✅ Created ${enhancement.description}`));
+            }
             addedCount++;
             addedFiles.push(enhancement.name);
           } catch (createError) {
@@ -629,19 +671,19 @@ async function scaffoldProject(options) {
         console.log('3. Push to trigger automated publishing');
         console.log('4. Your existing CAWS tools remain unchanged');
       } else {
-        console.log('2. Customize your working spec in .caws/working-spec.yaml');
-        console.log('3. Run validation: caws validate --suggestions');
+        console.log('2. Run: caws validate (verify setup)');
+        console.log('3. Run: caws diagnose (check project health)');
+        console.log('4. Customize .caws/working-spec.yaml for your project');
+        console.log('5. Optional: Create .caws/policy.yaml for tier-specific budgets');
         if (!qualityGatesAdded && !options.minimal) {
           console.log(
-            chalk.gray('4. Note: Quality gates scripts skipped (git hooks use CAWS CLI by default)')
+            chalk.gray('6. Note: Quality gates scripts skipped (git hooks use CAWS CLI by default)')
           );
           console.log(
             chalk.gray(
               '   Add --with-quality-gates flag if you want local scripts without global CLI'
             )
           );
-        } else {
-          console.log('4. Your existing CAWS tools remain unchanged');
         }
       }
     }

package/dist/spec/SpecFileManager.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Spec File Manager - Handles WorkingSpec file operations and YAML conversion
+ *
+ * Features:
+ * - Bidirectional WorkingSpec ↔ YAML conversion
+ * - Temporary file support for validation workflows
+ * - Backup/restore capabilities
+ * - Automatic cleanup of old temporary files
+ */
+export class SpecFileManager {
+    constructor(config?: {});
+    projectRoot: any;
+    useTemporaryFiles: any;
+    tempDir: any;
+    /**
+     * Convert WorkingSpec object to YAML string
+     *
+     * @param {Object} spec - WorkingSpec to convert
+     * @returns {string} YAML string representation
+     */
+    specToYaml(spec: any): string;
+    /**
+     * Parse YAML string to WorkingSpec object
+     *
+     * @param {string} yamlContent - YAML string to parse
+     * @returns {Object} Parsed WorkingSpec object
+     * @throws {Error} If YAML is invalid or doesn't match WorkingSpec schema
+     */
+    yamlToSpec(yamlContent: string): any;
+    /**
+     * Get path to .caws/working-spec.yaml in project
+     *
+     * @returns {string} Absolute path to working spec file
+     */
+    getSpecFilePath(): string;
+    /**
+     * Check if working spec file exists
+     *
+     * @returns {Promise<boolean>} True if file exists
+     */
+    specFileExists(): Promise<boolean>;
+    /**
+     * Read working spec from .caws/working-spec.yaml
+     *
+     * @returns {Promise<Object>} Parsed WorkingSpec object
+     * @throws {Error} If file doesn't exist or is invalid
+     */
+    readSpecFile(): Promise<any>;
+    /**
+     * Write WorkingSpec to file
+     *
+     * Writes to .caws/working-spec.yaml or a temporary file based on configuration.
+     *
+     * @param {Object} spec - WorkingSpec to write
+     * @param {Object} options - Write options
+     * @param {boolean} options.useTemp - Override temp file usage
+     * @param {boolean} options.backup - Create backup before writing
+     * @returns {Promise<Object>} Write result with file path and cleanup function
+     */
+    writeSpecFile(spec: any, options?: {
+        useTemp: boolean;
+        backup: boolean;
+    }): Promise<any>;
+    /**
+     * Update existing working spec file
+     *
+     * Reads current spec, merges changes, and writes back.
+     *
+     * @param {Object} updates - Partial WorkingSpec with fields to update
+     * @returns {Promise<Object>} Updated WorkingSpec
+     */
+    updateSpecFile(updates: any): Promise<any>;
+    /**
+     * Create backup of working spec
+     *
+     * @returns {Promise<string>} Path to backup file
+     */
+    backupSpecFile(): Promise<string>;
+    /**
+     * Restore working spec from backup
+     *
+     * @param {string} backupPath - Path to backup file
+     * @returns {Promise<void>}
+     */
+    restoreSpecFile(backupPath: string): Promise<void>;
+    /**
+     * List all backup files
+     *
+     * @returns {Promise<string[]>} Array of backup file paths
+     */
+    listBackups(): Promise<string[]>;
+    /**
+     * Delete old backup files
+     *
+     * @param {Object} options - Cleanup options
+     * @param {number} options.maxAge - Maximum age in milliseconds (default: 7 days)
+     * @param {number} options.keep - Minimum number of backups to keep (default: 5)
+     * @returns {Promise<number>} Number of backups deleted
+     */
+    cleanupBackups(options?: {
+        maxAge: number;
+        keep: number;
+    }): Promise<number>;
+    /**
+     * Validate spec file exists and is parseable
+     *
+     * @returns {Promise<Object>} Validation result
+     */
+    validateSpecFile(): Promise<any>;
+    /**
+     * Clean up old temporary spec files
+     *
+     * Removes temp files older than specified age.
+     *
+     * @param {number} maxAge - Maximum age in milliseconds (default: 1 hour)
+     * @returns {Promise<number>} Number of files cleaned up
+     */
+    cleanupTempFiles(maxAge?: number): Promise<number>;
+    /**
+     * Get spec file stats (size, modified date, etc.)
+     *
+     * @returns {Promise<Object>} File stats
+     */
+    getSpecFileStats(): Promise<any>;
+    /**
+     * Create a new SpecFileManager instance with different configuration
+     *
+     * @param {Object} config - New configuration
+     * @returns {SpecFileManager} New instance
+     */
+    withConfig(config: any): SpecFileManager;
+}
+export const defaultSpecFileManager: SpecFileManager;
+/**
+ * Create a SpecFileManager instance with default configuration
+ *
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Additional options
+ * @returns {SpecFileManager} SpecFileManager instance
+ */
+export function createSpecFileManager(projectRoot: string, options?: any): SpecFileManager;
+export declare function specToYaml(spec: any): string;
+export declare function yamlToSpec(yaml: any): any;
+export declare function readSpecFile(projectRoot: any): Promise<any>;
+export declare function writeSpecFile(spec: any, projectRoot: any, options: any): Promise<any>;
+//# sourceMappingURL=SpecFileManager.d.ts.map

package/dist/spec/SpecFileManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecFileManager.d.ts","sourceRoot":"","sources":["../../src/spec/SpecFileManager.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH;IACE,yBAIC;IAHC,iBAAsD;IACtD,uBAA0D;IAC1D,aAA4C;IAG9C;;;;;OAKG;IACH,uBAFa,MAAM,CASlB;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,OAqBhB;IAED;;;;OAIG;IACH,mBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;OAKG;IACH,gBAHa,OAAO,KAAQ,CAe3B;IAED;;;;;;;;;;OAUG;IACH,mCAJG;QAAyB,OAAO,EAAxB,OAAO;QACU,MAAM,EAAvB,OAAO;KACf,GAAU,OAAO,KAAQ,CA2C3B;IAED;;;;;;;OAOG;IACH,8BAFa,OAAO,KAAQ,CAa3B;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;OAIG;IACH,eAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;OAOG;IACH,yBAJG;QAAwB,MAAM,EAAtB,MAAM;QACU,IAAI,EAApB,MAAM;KACd,GAAU,OAAO,CAAC,MAAM,CAAC,CA+B3B;IAED;;;;OAIG;IACH,oBAFa,OAAO,KAAQ,CAe3B;IAED;;;;;;;OAOG;IACH,0BAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CA6B3B;IAED;;;;OAIG;IACH,oBAFa,OAAO,KAAQ,CA0B3B;IAED;;;;;OAKG;IACH,yBAFa,eAAe,CAS3B;CACF;AAiBD,qDAAqD;AAfrD;;;;;;GAMG;AACH,mDAJW,MAAM,kBAEJ,eAAe,CAO3B;AAWa,sDAAiD;AACjD,mDAAiD;AAC/C,qEAKb;AACc,+FAKd"}