@kadi.build/deploy-ability 0.0.1

package/dist/targets/akash/bid-selectors.js

@@ -0,0 +1,322 @@
+/**
+ * Bid Selection Helpers
+ *
+ * Provides pre-built selection strategies and filtering utilities for choosing
+ * providers based on different criteria. These functions can be used directly
+ * as bidSelectors in the deployment flow, or combined to create custom
+ * selection logic.
+ *
+ * **Selection Strategies:**
+ * - `selectCheapestBid` - Lowest price (perMonth basis)
+ * - `selectMostReliableBid` - Highest uptime percentage
+ * - `selectBalancedBid` - Weighted combination of price and reliability
+ *
+ * **Filtering:**
+ * - `filterBids` - Apply multiple criteria to narrow down options
+ *
+ * @module targets/akash/bid-selectors
+ */
+/**
+ * Select the cheapest bid based on monthly price
+ *
+ * Compares all bids and returns the one with the lowest cost per month.
+ * Useful when price is the primary concern and provider quality is
+ * less critical (e.g., development/testing deployments).
+ *
+ * **Note:** This only considers price, not provider reliability, location,
+ * or audit status. For production deployments, consider using `filterBids`
+ * first to ensure minimum quality standards, then select the cheapest
+ * from the filtered set.
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @returns The cheapest bid, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * import { deployToAkash, selectCheapestBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'dev',
+ *   bidSelector: selectCheapestBid
+ * });
+ * ```
+ *
+ * @example With quality filtering
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'prod',
+ *   bidSelector: (bids) => {
+ *     // Only consider audited providers with good uptime
+ *     const qualityBids = filterBids(bids, {
+ *       requireAudited: true,
+ *       minUptime: { value: 0.95, period: '7d' }
+ *     });
+ *     // Then pick cheapest among quality providers
+ *     return selectCheapestBid(qualityBids);
+ *   }
+ * });
+ * ```
+ */
+export function selectCheapestBid(bids) {
+    if (bids.length === 0)
+        return null;
+    return bids.reduce((cheapest, current) => current.pricing.uakt.perMonth < cheapest.pricing.uakt.perMonth
+        ? current
+        : cheapest);
+}
+/**
+ * Select the most reliable provider based on uptime
+ *
+ * Chooses the provider with the highest uptime percentage for the specified
+ * time period. Providers without reliability data are considered last.
+ *
+ * **Uptime Periods:**
+ * - `1d`: Last 24 hours (most recent, but limited sample)
+ * - `7d`: Last 7 days (good balance, recommended default)
+ * - `30d`: Last 30 days (long-term stability indicator)
+ *
+ * **Fallback Behavior:**
+ * If no providers have reliability data, returns the first bid from the
+ * original array (maintains deterministic behavior).
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @param period - Uptime period to evaluate (default: '7d')
+ * @returns The most reliable bid, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * import { deployToAkash, selectMostReliableBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: selectMostReliableBid // Uses 7d default
+ * });
+ * ```
+ *
+ * @example With custom period
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: (bids) => selectMostReliableBid(bids, '30d')
+ * });
+ * ```
+ */
+export function selectMostReliableBid(bids, period = '7d') {
+    if (bids.length === 0)
+        return null;
+    // Filter bids that have reliability data
+    const withReliability = bids.filter((bid) => bid.provider.reliability !== undefined);
+    // If no providers have reliability data, return first bid
+    if (withReliability.length === 0) {
+        return bids[0] ?? null;
+    }
+    // Determine uptime key based on period
+    const uptimeKey = `uptime${period}`;
+    // Find provider with highest uptime
+    return withReliability.reduce((best, current) => {
+        const bestUptime = best.provider.reliability[uptimeKey];
+        const currentUptime = current.provider.reliability[uptimeKey];
+        return currentUptime > bestUptime ? current : best;
+    });
+}
+/**
+ * Select bid using balanced scoring (price + reliability)
+ *
+ * Calculates a composite score for each bid based on normalized price
+ * and reliability metrics, then selects the highest-scoring option.
+ *
+ * **Scoring Methodology:**
+ * - Price score: Normalized 0-1 (lower price = higher score)
+ * - Reliability score: Uptime percentage (0-1)
+ * - Total score = (price score × price weight) + (reliability score × reliability weight)
+ *
+ * **Default Weights:**
+ * Equal balance (0.5 each) - adjust based on your priorities.
+ *
+ * **Use Cases:**
+ * - Production deployments where both cost and reliability matter
+ * - Finding "best value" providers (good balance of quality and price)
+ * - Avoiding both the cheapest-but-unreliable and expensive-but-reliable extremes
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @param weights - Scoring weights (default: equal balance)
+ * @param weights.price - Weight for price score (0-1)
+ * @param weights.reliability - Weight for reliability score (0-1)
+ * @returns The best balanced bid, or null if array is empty
+ *
+ * @example Equal balance (default)
+ * ```typescript
+ * import { deployToAkash, selectBalancedBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: selectBalancedBid // 50/50 price/reliability
+ * });
+ * ```
+ *
+ * @example Prioritize reliability
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'critical-prod',
+ *   bidSelector: (bids) => selectBalancedBid(bids, {
+ *     price: 0.3,
+ *     reliability: 0.7
+ *   })
+ * });
+ * ```
+ *
+ * @example Prioritize cost
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'dev',
+ *   bidSelector: (bids) => selectBalancedBid(bids, {
+ *     price: 0.8,
+ *     reliability: 0.2
+ *   })
+ * });
+ * ```
+ */
+export function selectBalancedBid(bids, weights = { price: 0.5, reliability: 0.5 }) {
+    if (bids.length === 0)
+        return null;
+    // Calculate price range for normalization
+    const prices = bids.map((bid) => bid.pricing.uakt.perMonth);
+    const minPrice = Math.min(...prices);
+    const maxPrice = Math.max(...prices);
+    const priceRange = maxPrice - minPrice;
+    // Calculate scores for each bid
+    const scored = bids.map((bid) => {
+        // Price score: 1.0 for cheapest, 0.0 for most expensive
+        // Handle case where all bids have same price
+        const priceScore = priceRange === 0
+            ? 1.0
+            : 1.0 - (bid.pricing.uakt.perMonth - minPrice) / priceRange;
+        // Reliability score: uptime7d (0.0 to 1.0)
+        // Default to 0.5 if no reliability data available
+        const reliabilityScore = bid.provider.reliability?.uptime7d ?? 0.5;
+        // Weighted total score
+        const totalScore = priceScore * weights.price + reliabilityScore * weights.reliability;
+        return { bid, score: totalScore };
+    });
+    // Return bid with highest score
+    return scored.reduce((best, current) => current.score > best.score ? current : best).bid;
+}
+/**
+ * Filter bids by multiple criteria
+ *
+ * Apply various filters to narrow down bid options based on price,
+ * reliability, audit status, location, and provider status.
+ *
+ * **All criteria are optional** - only specify the ones you care about.
+ * Multiple criteria are combined with AND logic (all must match).
+ *
+ * **Filtering Philosophy:**
+ * Use this to establish minimum quality standards, then apply a selection
+ * strategy to the filtered results. This ensures you never select a provider
+ * that doesn't meet your requirements, even if they're the cheapest.
+ *
+ * @param bids - Array of enhanced bids to filter
+ * @param criteria - Filtering criteria (all optional)
+ * @returns Filtered array of bids matching all specified criteria
+ *
+ * @example Filter by price and uptime
+ * ```typescript
+ * import { filterBids, selectCheapestBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'prod',
+ *   bidSelector: (bids) => {
+ *     // Only providers under $50/month with >95% uptime
+ *     const filtered = filterBids(bids, {
+ *       maxPricePerMonth: { usd: 50, aktPrice: 0.45 },
+ *       minUptime: { value: 0.95, period: '7d' }
+ *     });
+ *     return selectCheapestBid(filtered);
+ *   }
+ * });
+ * ```
+ *
+ * @example Filter by audit status and location
+ * ```typescript
+ * const filtered = filterBids(bids, {
+ *   requireAudited: true,
+ *   preferredRegions: ['US', 'EU'], // Country codes
+ *   requireOnline: true
+ * });
+ * ```
+ *
+ * @example Price filtering in uAKT
+ * ```typescript
+ * const filtered = filterBids(bids, {
+ *   maxPricePerMonth: { uakt: 500_000_000 } // 500M uAKT/month
+ * });
+ * ```
+ */
+export function filterBids(bids, criteria) {
+    return bids.filter((bid) => {
+        // Price filter
+        if (criteria.maxPricePerMonth) {
+            const maxPrice = 'uakt' in criteria.maxPricePerMonth
+                ? criteria.maxPricePerMonth.uakt
+                : bid.pricing.toUSD(criteria.maxPricePerMonth.aktPrice).perMonth;
+            const bidPrice = 'uakt' in criteria.maxPricePerMonth
+                ? bid.pricing.uakt.perMonth
+                : bid.pricing.toUSD(criteria.maxPricePerMonth.aktPrice).perMonth;
+            if (bidPrice > maxPrice)
+                return false;
+        }
+        // Uptime filter
+        if (criteria.minUptime) {
+            const { value, period } = criteria.minUptime;
+            const uptimeKey = `uptime${period}`;
+            const uptime = bid.provider.reliability?.[uptimeKey];
+            // If no reliability data, exclude this bid
+            if (uptime === undefined || uptime < value)
+                return false;
+        }
+        // Audit status filter
+        if (criteria.requireAudited && !bid.provider.isAudited) {
+            return false;
+        }
+        // Region filter
+        if (criteria.preferredRegions && criteria.preferredRegions.length > 0) {
+            const countryCode = bid.provider.location?.countryCode;
+            if (!countryCode || !criteria.preferredRegions.includes(countryCode)) {
+                return false;
+            }
+        }
+        // Online status filter
+        if (criteria.requireOnline) {
+            const isOnline = bid.provider.reliability?.isOnline;
+            if (isOnline !== true)
+                return false;
+        }
+        // All filters passed
+        return true;
+    });
+}
+//# sourceMappingURL=bid-selectors.js.map

package/dist/targets/akash/bid-selectors.js.map

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

package/dist/targets/akash/bid-types.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Bid Types and Pricing
+ *
+ * Type definitions for enhanced provider bids including comprehensive pricing
+ * calculations across multiple time periods (hour, day, week, month) and
+ * currencies (uAKT, AKT, USD).
+ *
+ * @module targets/akash/bid-types
+ */
+import type { Bid as ProviderBid } from '@akashnetwork/akash-api/akash/market/v1beta4';
+import type { ProviderInfo } from './provider-metadata.js';
+/**
+ * Comprehensive bid pricing across multiple time periods and currencies
+ *
+ * Provides pre-calculated pricing for a lease in various formats to support
+ * different use cases and display preferences. All calculations are derived
+ * from the raw per-block price returned by the blockchain.
+ *
+ * **Price Calculation Background:**
+ *
+ * Akash leases are priced per block on the blockchain. The raw price from
+ * providers is in uAKT (micro AKT) per block. We calculate prices for
+ * different time periods using:
+ * - Blocks per hour = 3600 seconds/hour ÷ 6.098 seconds/block ≈ 590.8 blocks
+ * - Blocks per day = 24 hours × blocks per hour ≈ 14,179 blocks
+ * - Blocks per week = 7 days × blocks per day ≈ 99,254 blocks
+ * - Blocks per month = 30.437 days × blocks per day ≈ 431,572 blocks
+ *
+ * **USD Conversion:**
+ *
+ * USD prices require the current AKT market price, which must be provided
+ * by the caller via the `toUSD()` method. This keeps the library free from
+ * external API dependencies while allowing flexible price display.
+ *
+ * @example Display pricing in multiple formats
+ * ```typescript
+ * const bid: EnhancedBid = // ... from queryBids
+ *
+ * // Display in uAKT
+ * console.log(`${bid.pricing.uakt.perMonth} uAKT/month`);
+ *
+ * // Display in AKT
+ * console.log(`${bid.pricing.akt.perMonth.toFixed(2)} AKT/month`);
+ *
+ * // Display in USD (requires AKT price)
+ * const aktPrice = 0.50; // $0.50 per AKT
+ * const usd = bid.pricing.toUSD(aktPrice);
+ * console.log(`$${usd.perMonth.toFixed(2)}/month`);
+ * console.log(`$${usd.perHour.toFixed(4)}/hour`);
+ * ```
+ */
+export interface BidPricing {
+    /**
+     * Raw price from blockchain (per block)
+     *
+     * This is the authoritative source - all other prices are computed from this.
+     */
+    readonly raw: {
+        /** Denomination (typically "uakt") */
+        readonly denom: string;
+        /** Amount per block as string */
+        readonly amount: string;
+    };
+    /**
+     * Pre-computed prices in uAKT for different time periods
+     *
+     * All values are in micro AKT (uAKT). To convert to AKT, divide by 1,000,000.
+     */
+    readonly uakt: {
+        /** Price in uAKT per block */
+        readonly perBlock: number;
+        /** Price in uAKT per hour (~590.8 blocks) */
+        readonly perHour: number;
+        /** Price in uAKT per day (~14,179 blocks) */
+        readonly perDay: number;
+        /** Price in uAKT per week (~99,254 blocks) */
+        readonly perWeek: number;
+        /** Price in uAKT per month (~431,572 blocks, 30.437 days) */
+        readonly perMonth: number;
+    };
+    /**
+     * Pre-computed prices in AKT (1 AKT = 1,000,000 uAKT)
+     *
+     * Convenient for display without manual conversion.
+     */
+    readonly akt: {
+        /** Price in AKT per block */
+        readonly perBlock: number;
+        /** Price in AKT per hour */
+        readonly perHour: number;
+        /** Price in AKT per day */
+        readonly perDay: number;
+        /** Price in AKT per week */
+        readonly perWeek: number;
+        /** Price in AKT per month */
+        readonly perMonth: number;
+    };
+    /**
+     * Convert prices to USD using current AKT market price
+     *
+     * **Important:** This method requires you to provide the current AKT price.
+     * deploy-ability does not fetch market data to remain pure and dependency-free.
+     *
+     * **Where to get AKT price:**
+     * - CoinGecko API: https://api.coingecko.com/api/v3/simple/price?ids=akash-network&vs_currencies=usd
+     * - Your own price oracle
+     * - Akash Console API (if available)
+     * - Cached/hardcoded value for estimates
+     *
+     * @param aktPriceUSD - Current price of 1 AKT in USD
+     * @returns Prices in USD for different time periods
+     *
+     * @example
+     * ```typescript
+     * const aktPrice = 0.50; // $0.50 per AKT
+     * const usdPricing = bid.pricing.toUSD(aktPrice);
+     * console.log(`$${usdPricing.perMonth.toFixed(2)}/month`);
+     * ```
+     */
+    toUSD(aktPriceUSD: number): {
+        readonly perHour: number;
+        readonly perDay: number;
+        readonly perWeek: number;
+        readonly perMonth: number;
+    };
+}
+/**
+ * Create BidPricing instance from blockchain price data
+ *
+ * Calculates all time-period prices from the raw per-block price.
+ *
+ * @param price - Price object from blockchain bid
+ * @param price.denom - Denomination (typically "uakt")
+ * @param price.amount - Amount per block as string
+ * @returns Complete pricing information across all time periods
+ *
+ * @example
+ * ```typescript
+ * const pricing = createBidPricing({
+ *   denom: 'uakt',
+ *   amount: '1234'
+ * });
+ * console.log(pricing.akt.perMonth); // Monthly cost in AKT
+ * ```
+ */
+export declare function createBidPricing(price: {
+    denom: string;
+    amount: string;
+}): BidPricing;
+/**
+ * Enhanced provider bid with complete information
+ *
+ * Combines the raw blockchain bid data with enriched provider information
+ * and pre-calculated pricing. This is the primary type developers work with
+ * when selecting providers for their deployments.
+ *
+ * **Design Philosophy:**
+ *
+ * This type provides all the information needed to make an informed provider
+ * selection decision in a single, convenient package:
+ * - Provider identity and metadata
+ * - Location information for latency/compliance needs
+ * - Reliability metrics for quality assessment
+ * - Comprehensive pricing in multiple formats
+ * - Raw bid data for advanced use cases
+ *
+ * **Data Availability:**
+ *
+ * Not all fields will be populated for all providers:
+ * - New providers may not have reliability data yet
+ * - Some providers may not expose location information
+ * - Provider metadata (name, email, website) is optional
+ *
+ * Always check for undefined before using optional provider fields.
+ *
+ * @example Displaying bid information
+ * ```typescript
+ * function displayBid(bid: EnhancedBid, aktPrice: number): void {
+ *   const usd = bid.pricing.toUSD(aktPrice);
+ *
+ *   console.log(`
+ *     Provider: ${bid.provider.name || 'Unknown'}
+ *     Location: ${bid.provider.location?.country || 'Unknown'}
+ *     Uptime (7d): ${bid.provider.reliability
+ *       ? (bid.provider.reliability.uptime7d * 100).toFixed(1) + '%'
+ *       : 'No data'}
+ *     Price: $${usd.perMonth.toFixed(2)}/month
+ *     Audited: ${bid.provider.isAudited ? 'Yes' : 'No'}
+ *   `);
+ * }
+ * ```
+ *
+ * @example Filtering by criteria
+ * ```typescript
+ * function selectAffordableReliableBid(
+ *   bids: EnhancedBid[],
+ *   maxUsdPerMonth: number,
+ *   aktPrice: number,
+ *   minUptime: number
+ * ): EnhancedBid | null {
+ *   const filtered = bids.filter(bid => {
+ *     const usd = bid.pricing.toUSD(aktPrice);
+ *     const uptime = bid.provider.reliability?.uptime7d ?? 0;
+ *     return usd.perMonth <= maxUsdPerMonth && uptime >= minUptime;
+ *   });
+ *
+ *   return filtered[0] ?? null;
+ * }
+ * ```
+ */
+export interface EnhancedBid {
+    /**
+     * Unique identifier for this bid
+     *
+     * Constructed from the bid coordinates (owner/dseq/gseq/oseq/provider).
+     * Useful for React keys, logging, and bid tracking.
+     */
+    readonly id: string;
+    /**
+     * Raw bid data from Akash blockchain
+     *
+     * Contains the original protobuf bid object with all coordinates
+     * (bidId, price, state, etc.). Useful for advanced operations that
+     * need direct access to blockchain data.
+     */
+    readonly bid: ProviderBid;
+    /**
+     * Complete provider information
+     *
+     * Includes identity, location, reliability metrics, and audit status.
+     * Some fields may be undefined for providers without complete metadata.
+     */
+    readonly provider: ProviderInfo;
+    /**
+     * Pre-calculated pricing across all time periods
+     *
+     * Includes pricing in uAKT, AKT, and a method for USD conversion.
+     * Makes it easy to display prices in user-friendly formats.
+     */
+    readonly pricing: BidPricing;
+    /**
+     * When this bid was created
+     *
+     * Timestamp when the provider submitted the bid to the blockchain.
+     * Useful for sorting by bid age or showing "time since bid" UI.
+     */
+    readonly createdAt: Date;
+}
+/**
+ * Bid selection function signature
+ *
+ * A function that takes an array of enhanced bids and returns the selected bid
+ * (or null if none are acceptable). Can be synchronous or asynchronous to support
+ * different selection strategies:
+ *
+ * - **Synchronous**: Simple algorithmic selection (cheapest, most reliable, etc.)
+ * - **Asynchronous**: Interactive selection (user prompts, API calls, external validation)
+ *
+ * **Contract:**
+ * - Input: Array of at least one EnhancedBid
+ * - Output: Selected EnhancedBid or null if none are acceptable
+ * - Throws: Should not throw - return null instead for unacceptable bids
+ *
+ * **Return null when:**
+ * - No bids meet your criteria
+ * - User cancels selection (in interactive mode)
+ * - External validation fails
+ *
+ * @example Simple synchronous selector
+ * ```typescript
+ * const selectCheapest: BidSelector = (bids) => {
+ *   if (bids.length === 0) return null;
+ *   return bids.reduce((cheapest, current) =>
+ *     current.pricing.uakt.perMonth < cheapest.pricing.uakt.perMonth
+ *       ? current
+ *       : cheapest
+ *   );
+ * };
+ * ```
+ *
+ * @example Asynchronous interactive selector
+ * ```typescript
+ * const selectInteractive: BidSelector = async (bids) => {
+ *   console.log('Available providers:');
+ *   bids.forEach((bid, i) => {
+ *     console.log(`${i + 1}. ${bid.provider.name} - ${bid.pricing.akt.perMonth} AKT/month`);
+ *   });
+ *
+ *   const choice = await promptUser('Select provider (1-' + bids.length + '): ');
+ *   const index = parseInt(choice) - 1;
+ *
+ *   return bids[index] ?? null;
+ * };
+ * ```
+ */
+export type BidSelector = ((bids: EnhancedBid[]) => Promise<EnhancedBid | null>) | ((bids: EnhancedBid[]) => EnhancedBid | null);
+//# sourceMappingURL=bid-types.d.ts.map

package/dist/targets/akash/bid-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bid-types.d.ts","sourceRoot":"","sources":["../../../src/targets/akash/bid-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,IAAI,WAAW,EAAE,MAAM,8CAA8C,CAAC;AACvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAyB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE;QACZ,sCAAsC;QACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,iCAAiC;QACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IAEF;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE;QACb,8BAA8B;QAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,6CAA6C;QAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,8CAA8C;QAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,6DAA6D;QAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IAEF;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE;QACZ,6BAA6B;QAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,4BAA4B;QAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,2BAA2B;QAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,4BAA4B;QAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,6BAA6B;QAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG;QAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,UAAU,CA2Cb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAE1B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAEhC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAE7B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,MAAM,WAAW,GACnB,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,GACtD,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,WAAW,GAAG,IAAI,CAAC,CAAC"}