@renseiai/agentfactory-server 0.8.0

package/dist/src/token-storage.js

@@ -0,0 +1,263 @@
+/**
+ * OAuth Token Storage Module
+ *
+ * Manages Linear OAuth token lifecycle in Redis:
+ * - Store, retrieve, refresh, and revoke tokens
+ * - Automatic token refresh before expiration
+ * - Multi-workspace token support
+ */
+import { createLogger } from './logger.js';
+import { isRedisConfigured, redisSet, redisGet, redisDel, redisKeys } from './redis.js';
+const log = createLogger('token-storage');
+/**
+ * Key prefix for workspace tokens in KV
+ */
+const TOKEN_KEY_PREFIX = 'oauth:workspace:';
+/**
+ * Buffer time (in seconds) before expiration to trigger refresh
+ * Refresh tokens 5 minutes before they expire
+ */
+const REFRESH_BUFFER_SECONDS = 5 * 60;
+/**
+ * Build the KV key for a workspace token
+ */
+function buildTokenKey(workspaceId) {
+    return `${TOKEN_KEY_PREFIX}${workspaceId}`;
+}
+/**
+ * Store OAuth token for a workspace in Redis
+ *
+ * @param workspaceId - The Linear organization ID
+ * @param tokenResponse - The token data from OAuth exchange
+ * @param workspaceName - Optional workspace name for display
+ */
+export async function storeToken(workspaceId, tokenResponse, workspaceName) {
+    const now = Math.floor(Date.now() / 1000);
+    const storedToken = {
+        accessToken: tokenResponse.access_token,
+        refreshToken: tokenResponse.refresh_token,
+        tokenType: tokenResponse.token_type,
+        scope: tokenResponse.scope,
+        expiresAt: tokenResponse.expires_in
+            ? now + tokenResponse.expires_in
+            : undefined,
+        storedAt: now,
+        workspaceId,
+        workspaceName,
+    };
+    const key = buildTokenKey(workspaceId);
+    await redisSet(key, storedToken);
+    log.info('Stored OAuth token', { workspaceId, workspaceName });
+    return storedToken;
+}
+/**
+ * Retrieve OAuth token for a workspace from Redis
+ *
+ * @param workspaceId - The Linear organization ID
+ * @returns The stored token or null if not found
+ */
+export async function getToken(workspaceId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot retrieve token');
+        return null;
+    }
+    const key = buildTokenKey(workspaceId);
+    const token = await redisGet(key);
+    return token;
+}
+/**
+ * Check if a token needs to be refreshed
+ * Returns true if token expires within the buffer period
+ *
+ * @param token - The stored token to check
+ * @returns Whether the token should be refreshed
+ */
+export function shouldRefreshToken(token) {
+    // No expiration means token doesn't expire (Linear API tokens typically don't)
+    if (!token.expiresAt) {
+        return false;
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const timeUntilExpiry = token.expiresAt - now;
+    return timeUntilExpiry <= REFRESH_BUFFER_SECONDS;
+}
+/**
+ * Refresh an OAuth token using the refresh token
+ *
+ * @param token - The current stored token with refresh token
+ * @param clientId - The Linear OAuth client ID
+ * @param clientSecret - The Linear OAuth client secret
+ * @returns The new stored token or null if refresh failed
+ */
+export async function refreshToken(token, clientId, clientSecret) {
+    const workspaceId = token.workspaceId;
+    if (!token.refreshToken) {
+        log.warn('No refresh token available', { workspaceId });
+        return null;
+    }
+    try {
+        const response = await fetch('https://api.linear.app/oauth/token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: new URLSearchParams({
+                grant_type: 'refresh_token',
+                client_id: clientId,
+                client_secret: clientSecret,
+                refresh_token: token.refreshToken,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            log.error('Token refresh failed', {
+                workspaceId,
+                statusCode: response.status,
+                errorDetails: errorText,
+            });
+            return null;
+        }
+        const tokenResponse = (await response.json());
+        // Store the new token
+        const newToken = await storeToken(token.workspaceId, tokenResponse, token.workspaceName);
+        log.info('Refreshed OAuth token', { workspaceId });
+        return newToken;
+    }
+    catch (err) {
+        log.error('Token refresh error', { workspaceId, error: err });
+        return null;
+    }
+}
+/**
+ * Get a valid access token for a workspace, refreshing if necessary
+ *
+ * @param workspaceId - The Linear organization ID
+ * @param clientId - Optional OAuth client ID for refresh (defaults to env var)
+ * @param clientSecret - Optional OAuth client secret for refresh (defaults to env var)
+ * @returns The access token or null if not available
+ */
+export async function getAccessToken(workspaceId, clientId, clientSecret) {
+    const token = await getToken(workspaceId);
+    if (!token) {
+        return null;
+    }
+    // Check if token needs refresh
+    if (shouldRefreshToken(token)) {
+        const cid = clientId ?? process.env.LINEAR_CLIENT_ID;
+        const csecret = clientSecret ?? process.env.LINEAR_CLIENT_SECRET;
+        if (!cid || !csecret) {
+            log.warn('OAuth credentials not configured, cannot refresh token', { workspaceId });
+            // Return existing token even if it might be expiring soon
+            return token.accessToken;
+        }
+        const refreshedToken = await refreshToken(token, cid, csecret);
+        if (refreshedToken) {
+            return refreshedToken.accessToken;
+        }
+        // Refresh failed, return existing token
+        log.warn('Token refresh failed, using existing token', { workspaceId });
+        return token.accessToken;
+    }
+    return token.accessToken;
+}
+/**
+ * Delete a token from Redis (for cleanup or revocation)
+ *
+ * @param workspaceId - The Linear organization ID
+ * @returns Whether the deletion was successful
+ */
+export async function deleteToken(workspaceId) {
+    if (!isRedisConfigured()) {
+        log.warn('Redis not configured, cannot delete token');
+        return false;
+    }
+    const key = buildTokenKey(workspaceId);
+    const result = await redisDel(key);
+    log.info('Deleted OAuth token', { workspaceId });
+    return result > 0;
+}
+/**
+ * List all stored workspace tokens (for admin purposes)
+ * Note: This scans all keys with the token prefix
+ *
+ * @returns Array of workspace IDs with stored tokens
+ */
+export async function listStoredWorkspaces() {
+    if (!isRedisConfigured()) {
+        return [];
+    }
+    const keys = await redisKeys(`${TOKEN_KEY_PREFIX}*`);
+    return keys.map((key) => key.replace(TOKEN_KEY_PREFIX, ''));
+}
+/**
+ * Clean up expired tokens from Redis storage
+ * Should be called periodically (e.g., via cron job)
+ *
+ * @returns Number of tokens cleaned up
+ */
+export async function cleanupExpiredTokens() {
+    if (!isRedisConfigured()) {
+        return 0;
+    }
+    const workspaces = await listStoredWorkspaces();
+    const now = Math.floor(Date.now() / 1000);
+    let cleanedCount = 0;
+    for (const workspaceId of workspaces) {
+        const token = await getToken(workspaceId);
+        // Remove tokens that have expired (with some grace period)
+        // We add 1 hour grace period to avoid removing tokens that might still be usable
+        if (token?.expiresAt && token.expiresAt + 3600 < now) {
+            await deleteToken(workspaceId);
+            cleanedCount++;
+            log.info('Cleaned up expired token', { workspaceId });
+        }
+    }
+    return cleanedCount;
+}
+/**
+ * Fetch the current user's organization from Linear API
+ * Used after OAuth to determine which workspace the token belongs to
+ *
+ * @param accessToken - The OAuth access token
+ * @returns Organization info or null if fetch failed
+ */
+export async function fetchOrganization(accessToken) {
+    try {
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({
+                query: `
+          query {
+            organization {
+              id
+              name
+              urlKey
+            }
+          }
+        `,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            log.error('Failed to fetch organization', {
+                statusCode: response.status,
+                errorDetails: errorText,
+            });
+            return null;
+        }
+        const data = (await response.json());
+        if (data.errors) {
+            log.error('GraphQL errors fetching organization', { errors: data.errors });
+            return null;
+        }
+        return data.data?.organization ?? null;
+    }
+    catch (err) {
+        log.error('Error fetching organization', { error: err });
+        return null;
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared types for the server package
+ *
+ * AgentWorkType is re-exported from here until @renseiai/agentfactory-linear
+ * provides it. Consumers should import from this module.
+ */
+/**
+ * Type of agent work being performed based on issue status
+ */
+export type AgentWorkType = 'research' | 'backlog-creation' | 'development' | 'inflight' | 'qa' | 'acceptance' | 'refinement' | 'refinement-coordination' | 'coordination' | 'qa-coordination' | 'acceptance-coordination';
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,kBAAkB,GAClB,aAAa,GACb,UAAU,GACV,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,yBAAyB,GACzB,cAAc,GACd,iBAAiB,GACjB,yBAAyB,CAAA"}

package/dist/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared types for the server package
+ *
+ * AgentWorkType is re-exported from here until @renseiai/agentfactory-linear
+ * provides it. Consumers should import from this module.
+ */
+export {};

package/dist/src/webhook-idempotency.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Webhook Idempotency Module
+ *
+ * Prevents duplicate webhook processing using a two-layer approach:
+ * 1. In-memory Set for fast local checks (avoids network latency)
+ * 2. Redis for distributed/persistent storage (survives restarts)
+ *
+ * Uses webhookId (unique per delivery) as the primary key, falling back
+ * to sessionId if webhookId is not available.
+ */
+/**
+ * Generate an idempotency key from webhook data
+ * Prefers webhookId (unique per delivery), falls back to sessionId
+ */
+export declare function generateIdempotencyKey(webhookId: string | undefined, sessionId: string): string;
+/**
+ * Check if a webhook has already been processed
+ * First checks in-memory cache, then falls back to KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ * @returns Whether the webhook was already processed
+ */
+export declare function isWebhookProcessed(idempotencyKey: string): Promise<boolean>;
+/**
+ * Mark a webhook as processed in both memory and KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export declare function markWebhookProcessed(idempotencyKey: string): Promise<void>;
+/**
+ * Remove a webhook from processed state (for cleanup after failed spawn)
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export declare function unmarkWebhookProcessed(idempotencyKey: string): Promise<void>;
+/**
+ * Get current cache statistics (for monitoring)
+ */
+export declare function getCacheStats(): {
+    memorySize: number;
+    memoryExpiryMs: number;
+    kvExpirySeconds: number;
+};
+//# sourceMappingURL=webhook-idempotency.d.ts.map

package/dist/src/webhook-idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-idempotency.d.ts","sourceRoot":"","sources":["../../src/webhook-idempotency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAyCH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,GAChB,MAAM,CAOR;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC,CA4BlB;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAcf;AAWD;;GAEG;AACH,wBAAgB,aAAa,IAAI;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;CACxB,CAMA"}

package/dist/src/webhook-idempotency.js

@@ -0,0 +1,148 @@
+/**
+ * Webhook Idempotency Module
+ *
+ * Prevents duplicate webhook processing using a two-layer approach:
+ * 1. In-memory Set for fast local checks (avoids network latency)
+ * 2. Redis for distributed/persistent storage (survives restarts)
+ *
+ * Uses webhookId (unique per delivery) as the primary key, falling back
+ * to sessionId if webhookId is not available.
+ */
+import { isRedisConfigured, redisSet, redisExists, redisDel } from './redis.js';
+const log = {
+    info: (msg, data) => console.log(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[idempotency] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/**
+ * Key prefix for webhook idempotency keys in KV
+ */
+const WEBHOOK_KEY_PREFIX = 'webhook:processed:';
+/**
+ * Time window for deduplication (24 hours)
+ * Linear's retry window is typically 24-48 hours
+ */
+const DEDUP_WINDOW_SECONDS = 24 * 60 * 60;
+/**
+ * In-memory expiry for local cache (5 minutes)
+ * Shorter than KV to prevent memory growth
+ */
+const MEMORY_EXPIRY_MS = 5 * 60 * 1000;
+/**
+ * In-memory cache for fast local checks
+ * Maps idempotency key to timestamp when it was added
+ */
+const processedWebhooks = new Map();
+/**
+ * Build the KV key for a webhook idempotency entry
+ */
+function buildWebhookKey(idempotencyKey) {
+    return `${WEBHOOK_KEY_PREFIX}${idempotencyKey}`;
+}
+/**
+ * Generate an idempotency key from webhook data
+ * Prefers webhookId (unique per delivery), falls back to sessionId
+ */
+export function generateIdempotencyKey(webhookId, sessionId) {
+    // webhookId is unique per delivery attempt - best for idempotency
+    if (webhookId) {
+        return `wh:${webhookId}`;
+    }
+    // Fallback to sessionId if webhookId not available
+    return `session:${sessionId}`;
+}
+/**
+ * Check if a webhook has already been processed
+ * First checks in-memory cache, then falls back to KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ * @returns Whether the webhook was already processed
+ */
+export async function isWebhookProcessed(idempotencyKey) {
+    // Fast path: check in-memory cache first
+    if (processedWebhooks.has(idempotencyKey)) {
+        log.info(`Cache hit (memory): ${idempotencyKey}`);
+        return true;
+    }
+    // Slow path: check Redis for distributed/persistent state
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            const exists = await redisExists(key);
+            if (exists) {
+                log.info(`Cache hit (Redis): ${idempotencyKey}`);
+                // Warm up memory cache for subsequent checks
+                processedWebhooks.set(idempotencyKey, Date.now());
+                scheduleMemoryCleanup(idempotencyKey);
+                return true;
+            }
+        }
+        catch (err) {
+            // Log but don't fail - better to potentially double-process
+            // than to block legitimate webhooks
+            log.error('KV check failed', { error: err });
+        }
+    }
+    return false;
+}
+/**
+ * Mark a webhook as processed in both memory and KV
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export async function markWebhookProcessed(idempotencyKey) {
+    // Always update memory cache
+    processedWebhooks.set(idempotencyKey, Date.now());
+    scheduleMemoryCleanup(idempotencyKey);
+    // Persist to Redis for distributed state
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            await redisSet(key, Date.now(), DEDUP_WINDOW_SECONDS);
+            log.info(`Marked processed in Redis: ${idempotencyKey}`);
+        }
+        catch (err) {
+            // Log but don't fail - memory cache provides some protection
+            log.error('Redis write failed', { error: err });
+        }
+    }
+}
+/**
+ * Remove a webhook from processed state (for cleanup after failed spawn)
+ *
+ * @param idempotencyKey - The key generated from generateIdempotencyKey
+ */
+export async function unmarkWebhookProcessed(idempotencyKey) {
+    // Remove from memory
+    processedWebhooks.delete(idempotencyKey);
+    // Remove from Redis
+    if (isRedisConfigured()) {
+        try {
+            const key = buildWebhookKey(idempotencyKey);
+            await redisDel(key);
+            log.info(`Removed from Redis: ${idempotencyKey}`);
+        }
+        catch (err) {
+            log.error('Redis delete failed', { error: err });
+        }
+    }
+}
+/**
+ * Schedule cleanup of memory cache entry after expiry
+ */
+function scheduleMemoryCleanup(idempotencyKey) {
+    setTimeout(() => {
+        processedWebhooks.delete(idempotencyKey);
+    }, MEMORY_EXPIRY_MS);
+}
+/**
+ * Get current cache statistics (for monitoring)
+ */
+export function getCacheStats() {
+    return {
+        memorySize: processedWebhooks.size,
+        memoryExpiryMs: MEMORY_EXPIRY_MS,
+        kvExpirySeconds: DEDUP_WINDOW_SECONDS,
+    };
+}

package/dist/src/work-queue.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Work Queue Module (Optimized)
+ *
+ * Manages the queue of pending agent work items in Redis.
+ * Workers poll this queue to claim and process work.
+ *
+ * Data Structures (optimized for high concurrency):
+ * - work:items (Hash): sessionId -> JSON work item - O(1) lookup
+ * - work:queue (Sorted Set): score = priority, member = sessionId - O(log n) operations
+ * - work:claim:{sessionId} (String): workerId with TTL - atomic claims
+ *
+ * Performance:
+ * - queueWork: O(log n) - HSET + ZADD
+ * - claimWork: O(log n) - SETNX + HGET + ZREM
+ * - peekWork: O(log n + k) - ZRANGEBYSCORE + HMGET where k = limit
+ * - getQueueLength: O(1) - ZCARD
+ */
+import type { AgentWorkType } from './types.js';
+/**
+ * Type of work being performed
+ * @deprecated Use AgentWorkType from './types.js' instead
+ */
+export type WorkType = AgentWorkType;
+/**
+ * Work item stored in the queue
+ */
+export interface QueuedWork {
+    sessionId: string;
+    issueId: string;
+    issueIdentifier: string;
+    priority: number;
+    queuedAt: number;
+    prompt?: string;
+    providerSessionId?: string;
+    workType?: AgentWorkType;
+    sourceSessionId?: string;
+    projectName?: string;
+}
+/**
+ * Add work to the queue
+ *
+ * @param work - Work item to queue
+ * @returns true if queued successfully
+ */
+export declare function queueWork(work: QueuedWork): Promise<boolean>;
+/**
+ * Peek at pending work without removing from queue
+ * Returns items sorted by priority (lowest number = highest priority)
+ *
+ * @param limit - Maximum number of items to return
+ * @returns Array of work items sorted by priority
+ */
+export declare function peekWork(limit?: number): Promise<QueuedWork[]>;
+/**
+ * Get the number of items in the queue
+ */
+export declare function getQueueLength(): Promise<number>;
+/**
+ * Claim a work item for processing
+ *
+ * Uses SETNX for atomic claim to prevent race conditions.
+ * O(log n) complexity for claim + remove operations.
+ *
+ * @param sessionId - Session ID to claim
+ * @param workerId - Worker claiming the work
+ * @returns The work item if claimed successfully, null otherwise
+ */
+export declare function claimWork(sessionId: string, workerId: string): Promise<QueuedWork | null>;
+/**
+ * Release a work claim (e.g., on failure or cancellation)
+ *
+ * @param sessionId - Session ID to release
+ * @returns true if released successfully
+ */
+export declare function releaseClaim(sessionId: string): Promise<boolean>;
+/**
+ * Check which worker has claimed a session
+ *
+ * @param sessionId - Session ID to check
+ * @returns Worker ID if claimed, null otherwise
+ */
+export declare function getClaimOwner(sessionId: string): Promise<string | null>;
+/**
+ * Check if a session has an entry in the work queue.
+ * O(1) check via the work items hash.
+ *
+ * @param sessionId - Session ID to check
+ * @returns true if the session is present in the work queue
+ */
+export declare function isSessionInQueue(sessionId: string): Promise<boolean>;
+/**
+ * Re-queue work that failed or was abandoned
+ *
+ * @param work - Work item to re-queue
+ * @param priorityBoost - Decrease priority number (higher priority) by this amount
+ * @returns true if re-queued successfully
+ */
+export declare function requeueWork(work: QueuedWork, priorityBoost?: number): Promise<boolean>;
+/**
+ * Get all pending work items (for dashboard/monitoring)
+ * Returns items sorted by priority
+ */
+export declare function getAllPendingWork(): Promise<QueuedWork[]>;
+/**
+ * Remove a work item from queue (without claiming)
+ * Used for cleanup operations
+ *
+ * @param sessionId - Session ID to remove
+ * @returns true if removed
+ */
+export declare function removeFromQueue(sessionId: string): Promise<boolean>;
+/**
+ * Migrate data from legacy list-based queue to new sorted set/hash structure
+ * Run this once after deployment to migrate existing data
+ */
+export declare function migrateFromLegacyQueue(): Promise<{
+    migrated: number;
+    failed: number;
+}>;
+//# sourceMappingURL=work-queue.d.ts.map

package/dist/src/work-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-queue.d.ts","sourceRoot":"","sources":["../../src/work-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAqBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAoB/C;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAA;AAEpC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAeD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CA4BlE;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAuCxE;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAWtD;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgE5B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAatE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAY7E;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAY1E;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,EAChB,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC,OAAO,CAAC,CAwBlB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAgC/D;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAczE;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAC,CA8CD"}