@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/orchestrator/webhook-orchestrator.js

@@ -0,0 +1,373 @@
+/**
+ * Webhook Orchestrator Factory
+ *
+ * Creates a singleton orchestrator instance configured for webhook-triggered
+ * agent spawning. Includes retry logic, idempotency, session state persistence,
+ * and error activity emission to Linear.
+ *
+ * Consumers provide lifecycle hooks (e.g., onAgentComplete) for custom behavior
+ * like marking issues as "agent-worked" for automated QA.
+ */
+import { createOrchestrator, } from '@renseiai/agentfactory';
+import { withRetry, AgentSpawnError, isRetryableError, createAgentSession, createLinearAgentClient, } from '@renseiai/agentfactory-linear';
+import { createLogger, generateIdempotencyKey, isWebhookProcessed, markWebhookProcessed, unmarkWebhookProcessed, storeSessionState, getSessionState, updateProviderSessionId, updateSessionStatus, updateSessionCostData, updateWorkflowState, recordPhaseAttempt, incrementCycleCount, appendFailureSummary, clearWorkflowState, extractFailureReason, markAcceptanceCompleted, } from '@renseiai/agentfactory-server';
+import { formatErrorForComment } from './error-formatting.js';
+const log = createLogger('webhook-orchestrator');
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 2,
+    initialDelayMs: 1000,
+    backoffMultiplier: 2,
+    maxDelayMs: 5000,
+    retryableStatusCodes: [429, 500, 502, 503, 504],
+};
+/**
+ * Resolve the Linear client lazily from environment.
+ * Used for error activity emission.
+ */
+function getLinearClientFromEnv() {
+    const apiKey = process.env.LINEAR_ACCESS_TOKEN;
+    if (!apiKey)
+        return null;
+    return createLinearAgentClient({ apiKey });
+}
+/**
+ * Determine if a spawn error is retryable.
+ */
+function isSpawnErrorRetryable(error) {
+    if (isRetryableError(error))
+        return true;
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        if (message.includes('lock') || message.includes('busy') || message.includes('temporary')) {
+            return true;
+        }
+        if (message.includes('not found') || message.includes('enoent')) {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Clean up resources after a failed spawn attempt.
+ */
+async function cleanupFailedSpawn(issueId, idempotencyKey) {
+    try {
+        await unmarkWebhookProcessed(idempotencyKey);
+        log.debug('Cleaned up resources for failed spawn', { issueId, idempotencyKey });
+    }
+    catch (cleanupError) {
+        log.error('Cleanup error', { issueId, idempotencyKey, error: cleanupError });
+    }
+}
+/**
+ * Emit an error activity to Linear for tracking agent failures.
+ */
+async function emitAgentErrorActivity(issueId, error, sessionId) {
+    try {
+        const client = getLinearClientFromEnv();
+        if (!client) {
+            log.warn('Cannot emit error activity: LINEAR_ACCESS_TOKEN not set');
+            return;
+        }
+        if (sessionId) {
+            const session = createAgentSession({
+                client: client.linearClient,
+                issueId,
+                sessionId,
+                autoTransition: false,
+            });
+            await session.emitError(error);
+        }
+        else {
+            const errorMessage = formatErrorForComment(error);
+            await client.createComment(issueId, errorMessage);
+        }
+        log.debug('Error activity emitted to Linear', { issueId, sessionId });
+    }
+    catch (emitError) {
+        log.error('Failed to emit error activity', { issueId, sessionId, error: emitError });
+    }
+}
+/**
+ * Create a webhook orchestrator instance.
+ *
+ * @param config - Orchestrator configuration
+ * @param hooks - Lifecycle hooks for custom behavior
+ * @returns A webhook orchestrator instance
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createWebhookOrchestrator(
+ *   { maxConcurrent: 10 },
+ *   {
+ *     onAgentComplete: async (agent) => {
+ *       await markAgentWorked(agent.issueId, { ... })
+ *     },
+ *   }
+ * )
+ * ```
+ */
+export function createWebhookOrchestrator(config, hooks) {
+    const retryConfig = config?.retryConfig ?? DEFAULT_RETRY_CONFIG;
+    let _orchestrator = null;
+    function getOrchestrator() {
+        if (!_orchestrator) {
+            const apiKey = process.env.LINEAR_ACCESS_TOKEN;
+            if (!apiKey) {
+                throw new Error('LINEAR_ACCESS_TOKEN not set - orchestrator initialization failed');
+            }
+            _orchestrator = createOrchestrator({
+                linearApiKey: apiKey,
+                maxConcurrent: config?.maxConcurrent ?? 10,
+                autoTransition: config?.autoTransition ?? true,
+            }, {
+                onAgentStart: (agent) => {
+                    log.info('Agent started', {
+                        agentIdentifier: agent.identifier,
+                        agentPid: agent.pid,
+                        issueId: agent.issueId,
+                        sessionId: agent.sessionId,
+                    });
+                },
+                onAgentComplete: async (agent) => {
+                    log.info('Agent completed', {
+                        agentIdentifier: agent.identifier,
+                        issueId: agent.issueId,
+                        sessionId: agent.sessionId,
+                        totalCostUsd: agent.totalCostUsd,
+                    });
+                    if (agent.sessionId && (agent.totalCostUsd != null || agent.inputTokens != null || agent.outputTokens != null)) {
+                        await updateSessionCostData(agent.sessionId, {
+                            totalCostUsd: agent.totalCostUsd,
+                            inputTokens: agent.inputTokens,
+                            outputTokens: agent.outputTokens,
+                        }).catch((err) => log.error('Failed to persist cost data', { error: err }));
+                    }
+                    // Track workflow state for result-sensitive work types
+                    try {
+                        const workType = agent.workType ?? 'development';
+                        const phaseMap = {
+                            development: 'development',
+                            qa: 'qa',
+                            'qa-coordination': 'qa',
+                            acceptance: 'acceptance',
+                            'acceptance-coordination': 'acceptance',
+                            refinement: 'refinement',
+                        };
+                        const phase = phaseMap[workType];
+                        if (phase) {
+                            // Ensure workflow state exists
+                            await updateWorkflowState(agent.issueId, {
+                                issueIdentifier: agent.identifier,
+                            });
+                            // Record the phase attempt
+                            await recordPhaseAttempt(agent.issueId, phase, {
+                                attempt: 1, // Will be refined by phase-specific logic
+                                sessionId: agent.sessionId,
+                                startedAt: agent.startedAt.getTime(),
+                                completedAt: agent.completedAt?.getTime(),
+                                result: agent.workResult ?? (phase === 'development' || phase === 'refinement' ? 'passed' : undefined),
+                                costUsd: agent.totalCostUsd,
+                            });
+                            // On QA/acceptance failure: increment cycle count and append failure summary
+                            const isResultSensitive = phase === 'qa' || phase === 'acceptance';
+                            if (isResultSensitive && (agent.workResult === 'failed' || agent.workResult === 'unknown')) {
+                                const state = await incrementCycleCount(agent.issueId);
+                                const failureReason = agent.workResult === 'unknown'
+                                    ? 'Agent completed without a structured WORK_RESULT marker (treated as failure)'
+                                    : extractFailureReason(agent.resultMessage);
+                                const formattedFailure = `--- Cycle ${state.cycleCount}, ${phase} (${new Date().toISOString()}) ---\n${failureReason}`;
+                                await appendFailureSummary(agent.issueId, formattedFailure);
+                                log.info('Workflow state updated after failure', {
+                                    issueId: agent.issueId,
+                                    cycleCount: state.cycleCount,
+                                    strategy: state.strategy,
+                                    phase,
+                                    workResult: agent.workResult,
+                                });
+                            }
+                            // On acceptance pass: clear workflow state (issue is done)
+                            if (phase === 'acceptance' && agent.workResult === 'passed') {
+                                await clearWorkflowState(agent.issueId);
+                                await markAcceptanceCompleted(agent.issueId);
+                                log.info('Workflow state cleared after acceptance pass', {
+                                    issueId: agent.issueId,
+                                });
+                            }
+                            // On acceptance failure/unknown: mark completed to prevent re-trigger loop.
+                            // The issue stays in Delivered but won't auto-fire another acceptance agent.
+                            if (phase === 'acceptance' && (agent.workResult === 'failed' || agent.workResult === 'unknown')) {
+                                await markAcceptanceCompleted(agent.issueId);
+                                log.info('Marked acceptance completed to prevent re-trigger loop', {
+                                    issueId: agent.issueId,
+                                    workResult: agent.workResult,
+                                });
+                            }
+                        }
+                    }
+                    catch (err) {
+                        log.error('Failed to update workflow state', { error: err, issueId: agent.issueId });
+                    }
+                    try {
+                        await hooks?.onAgentComplete?.(agent);
+                    }
+                    catch (err) {
+                        log.error('Hook onAgentComplete failed', { error: err });
+                    }
+                },
+                onAgentError: (agent, error) => {
+                    log.error('Agent failed', {
+                        agentIdentifier: agent.identifier,
+                        issueId: agent.issueId,
+                        sessionId: agent.sessionId,
+                        error,
+                    });
+                    emitAgentErrorActivity(agent.issueId, error, agent.sessionId).catch((err) => log.error('Failed to emit error activity', { error: err }));
+                    try {
+                        hooks?.onAgentError?.(agent, error);
+                    }
+                    catch (err) {
+                        log.error('Hook onAgentError failed', { error: err });
+                    }
+                },
+                onAgentStopped: (agent) => {
+                    log.info('Agent stopped', {
+                        agentIdentifier: agent.identifier,
+                        issueId: agent.issueId,
+                        sessionId: agent.sessionId,
+                    });
+                    if (agent.sessionId) {
+                        updateSessionStatus(agent.sessionId, 'stopped').catch((err) => log.error('Failed to update session status', { error: err }));
+                    }
+                    hooks?.onAgentStopped?.(agent);
+                },
+                onProviderSessionId: async (linearSessionId, providerSessionId) => {
+                    log.info('Provider session ID captured', { linearSessionId, providerSessionId });
+                    await updateProviderSessionId(linearSessionId, providerSessionId);
+                },
+            });
+        }
+        return _orchestrator;
+    }
+    return {
+        async spawnAgentAsync(issueId, sessionId, webhookId) {
+            const idempotencyKey = generateIdempotencyKey(webhookId, sessionId);
+            if (await isWebhookProcessed(idempotencyKey)) {
+                return { spawned: false, reason: 'duplicate_webhook' };
+            }
+            const orch = getOrchestrator();
+            if (orch.getActiveAgents().some((a) => a.issueId === issueId)) {
+                return { spawned: false, reason: 'agent_already_running' };
+            }
+            await markWebhookProcessed(idempotencyKey);
+            const spawnLog = log.child({ issueId, sessionId });
+            try {
+                const agent = await withRetry(async () => {
+                    return getOrchestrator().spawnAgentForIssue(issueId, sessionId);
+                }, {
+                    config: retryConfig,
+                    shouldRetry: isSpawnErrorRetryable,
+                    onRetry: ({ attempt, delay, lastError }) => {
+                        spawnLog.warn('Spawn retry attempt', {
+                            attempt: attempt + 1,
+                            maxRetries: retryConfig.maxRetries,
+                            delayMs: delay,
+                            lastErrorMessage: lastError?.message,
+                        });
+                    },
+                });
+                spawnLog.info('Agent spawn successful', {
+                    agentIdentifier: agent.identifier,
+                    agentPid: agent.pid,
+                });
+                await storeSessionState(sessionId, {
+                    issueId,
+                    providerSessionId: agent.providerSessionId ?? null,
+                    worktreePath: agent.worktreePath ?? '',
+                    status: 'running',
+                });
+                return { spawned: true, agent };
+            }
+            catch (error) {
+                const spawnError = error instanceof Error ? error : new Error(String(error));
+                const typedError = new AgentSpawnError(`Failed to spawn agent: ${spawnError.message}`, issueId, sessionId, isSpawnErrorRetryable(error), spawnError);
+                spawnLog.error('Failed to spawn agent after retries', {
+                    error: typedError,
+                    isRetryable: typedError.isRetryable,
+                });
+                await emitAgentErrorActivity(issueId, typedError, sessionId);
+                await cleanupFailedSpawn(issueId, idempotencyKey);
+                return { spawned: false, reason: 'spawn_failed', error: typedError };
+            }
+        },
+        async stopAgentBySession(sessionId, cleanupWorktree = true) {
+            const stopLog = log.child({ sessionId });
+            try {
+                const orch = getOrchestrator();
+                const result = await orch.stopAgentBySession(sessionId, cleanupWorktree);
+                if (result.stopped) {
+                    stopLog.info('Agent stopped by session', {
+                        agentIdentifier: result.agent?.identifier,
+                        cleanedWorktree: cleanupWorktree,
+                    });
+                }
+                else {
+                    stopLog.info('Could not stop agent', { reason: result.reason });
+                }
+                return result;
+            }
+            catch (error) {
+                stopLog.error('Failed to stop agent', { error });
+                throw error;
+            }
+        },
+        getAgentBySession(sessionId) {
+            return getOrchestrator().getAgentBySession(sessionId);
+        },
+        isAgentRunningForIssue(issueId) {
+            return getOrchestrator().getActiveAgents().some((a) => a.issueId === issueId);
+        },
+        async forwardPromptAsync(issueId, sessionId, promptText) {
+            const promptLog = log.child({ issueId, sessionId });
+            try {
+                const sessionState = await getSessionState(sessionId);
+                promptLog.info('Forwarding prompt to agent', {
+                    hasSessionState: !!sessionState,
+                    hasProviderSessionId: !!sessionState?.providerSessionId,
+                    promptLength: promptText.length,
+                    workType: sessionState?.workType ?? 'development',
+                });
+                const orch = getOrchestrator();
+                const result = await orch.forwardPrompt(issueId, sessionId, promptText, sessionState?.providerSessionId ?? undefined, sessionState?.workType);
+                if (result.forwarded) {
+                    promptLog.info('Prompt forwarded successfully', {
+                        resumed: result.resumed,
+                        agentIdentifier: result.agent?.identifier,
+                        agentPid: result.agent?.pid,
+                    });
+                    if (result.agent) {
+                        await storeSessionState(sessionId, {
+                            issueId,
+                            providerSessionId: result.agent.providerSessionId ?? null,
+                            worktreePath: result.agent.worktreePath ?? '',
+                            status: 'running',
+                            workType: sessionState?.workType,
+                        });
+                    }
+                }
+                else {
+                    promptLog.warn('Prompt not forwarded', {
+                        reason: result.reason,
+                        error: result.error?.message,
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error : new Error(String(error));
+                promptLog.error('Failed to forward prompt', { error: errorMsg });
+                return { forwarded: false, resumed: false, reason: 'spawn_failed', error: errorMsg };
+            }
+        },
+    };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Core types for @renseiai/agentfactory-nextjs
+ *
+ * These types define the configuration interfaces that consumers
+ * must implement to use the extracted route handlers.
+ */
+import type { NextResponse } from 'next/server';
+import type { LinearAgentClient, AgentWorkType, SubIssueStatus, WorkflowContext } from '@renseiai/agentfactory-linear';
+/**
+ * Resolves a Linear client for a given organization.
+ * Consumers implement this to handle workspace-specific OAuth tokens.
+ */
+export interface LinearClientResolver {
+    getClient(organizationId?: string): Promise<LinearAgentClient> | LinearAgentClient;
+}
+/**
+ * Base configuration for routes that need Linear API access.
+ */
+export interface RouteConfig {
+    linearClient: LinearClientResolver;
+    appUrl?: string;
+}
+/**
+ * Auto-trigger configuration for webhook processing.
+ */
+export interface AutoTriggerConfig {
+    enableAutoQA: boolean;
+    enableAutoAcceptance: boolean;
+    autoQARequireAgentWorked: boolean;
+    autoAcceptanceRequireAgentWorked: boolean;
+    autoQAProjects: string[];
+    autoAcceptanceProjects: string[];
+    autoQAExcludeLabels: string[];
+    autoAcceptanceExcludeLabels: string[];
+}
+/**
+ * Configuration for the webhook processor.
+ *
+ * `generatePrompt` is optional — if not provided, falls back to
+ * `defaultGeneratePrompt` from @renseiai/agentfactory-linear.
+ */
+export interface WebhookConfig extends RouteConfig {
+    webhookSecret?: string;
+    generatePrompt?: (identifier: string, workType: AgentWorkType, mentionContext?: string, workflowContext?: WorkflowContext) => string;
+    detectWorkTypeFromPrompt?: (prompt: string, validWorkTypes: AgentWorkType[]) => AgentWorkType | undefined;
+    getPriority?: (workType: AgentWorkType) => number;
+    autoTrigger?: AutoTriggerConfig;
+    buildParentQAContext?: (identifier: string, subIssues: SubIssueStatus[]) => string;
+    buildParentAcceptanceContext?: (identifier: string, subIssues: SubIssueStatus[]) => string;
+    /** Linear project names this server handles. Empty/undefined = all projects. */
+    projects?: string[];
+    /**
+     * Path to a directory containing custom workflow template YAML files.
+     * Templates in this directory override built-in defaults per work type.
+     */
+    templateDir?: string;
+    /**
+     * Governor integration mode:
+     * - 'direct' (default): Today's behavior -- webhooks dispatch work directly
+     * - 'event-bridge': Dual-write -- webhooks dispatch AND publish governor events
+     * - 'governor-only': Events only -- webhooks publish to governor, no direct dispatch
+     */
+    governorMode?: 'direct' | 'event-bridge' | 'governor-only';
+}
+/**
+ * Resolved webhook config with all defaults applied.
+ * Used internally by webhook handlers — generatePrompt is guaranteed to be set.
+ */
+export interface ResolvedWebhookConfig extends RouteConfig {
+    webhookSecret?: string;
+    generatePrompt: (identifier: string, workType: AgentWorkType, mentionContext?: string, workflowContext?: WorkflowContext) => string;
+    detectWorkTypeFromPrompt?: (prompt: string, validWorkTypes: AgentWorkType[]) => AgentWorkType | undefined;
+    getPriority?: (workType: AgentWorkType) => number;
+    autoTrigger?: AutoTriggerConfig;
+    buildParentQAContext?: (identifier: string, subIssues: SubIssueStatus[]) => string;
+    buildParentAcceptanceContext?: (identifier: string, subIssues: SubIssueStatus[]) => string;
+    /** Linear project names this server handles. Empty/undefined = all projects. */
+    projects?: string[];
+    /**
+     * Governor integration mode:
+     * - 'direct' (default): Today's behavior -- webhooks dispatch work directly
+     * - 'event-bridge': Dual-write -- webhooks dispatch AND publish governor events
+     * - 'governor-only': Events only -- webhooks publish to governor, no direct dispatch
+     */
+    governorMode?: 'direct' | 'event-bridge' | 'governor-only';
+}
+/**
+ * Configuration for cron-authenticated routes.
+ */
+export interface CronConfig {
+    cronSecret?: string;
+}
+/**
+ * Standard Next.js route handler signature.
+ *
+ * Uses `any` for the context parameter because Next.js App Router
+ * provides different shapes depending on the route segment (static
+ * routes get no context, dynamic `[id]` routes get `{ params }`).
+ */
+export type RouteHandler = (...args: any[]) => Promise<NextResponse>;
+//# 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":"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"}

package/dist/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * Core types for @renseiai/agentfactory-nextjs
+ *
+ * These types define the configuration interfaces that consumers
+ * must implement to use the extracted route handlers.
+ */
+export {};

package/dist/src/webhook/governor-bridge.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Governor Bridge
+ *
+ * Connects webhook handlers to the GovernorEventBus. When configured,
+ * webhook handlers publish events to the bus in addition to (or instead of)
+ * their normal direct-dispatch behavior.
+ */
+import type { GovernorEventBus, GovernorEvent } from '@renseiai/agentfactory';
+/**
+ * Configure the governor event bus for webhook bridging.
+ * Call this during server initialization when governorMode != 'direct'.
+ */
+export declare function setGovernorEventBus(bus: GovernorEventBus): void;
+/**
+ * Get the configured event bus, or null if not configured.
+ */
+export declare function getGovernorEventBus(): GovernorEventBus | null;
+/**
+ * Publish a GovernorEvent if a bus is configured.
+ * Returns the event ID if published, null if no bus is configured.
+ */
+export declare function publishGovernorEvent(event: GovernorEvent): Promise<string | null>;
+//# sourceMappingURL=governor-bridge.d.ts.map

package/dist/src/webhook/governor-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-bridge.d.ts","sourceRoot":"","sources":["../../../src/webhook/governor-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAI7E;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAE/D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQvF"}

package/dist/src/webhook/governor-bridge.js

@@ -0,0 +1,36 @@
+/**
+ * Governor Bridge
+ *
+ * Connects webhook handlers to the GovernorEventBus. When configured,
+ * webhook handlers publish events to the bus in addition to (or instead of)
+ * their normal direct-dispatch behavior.
+ */
+let _eventBus = null;
+/**
+ * Configure the governor event bus for webhook bridging.
+ * Call this during server initialization when governorMode != 'direct'.
+ */
+export function setGovernorEventBus(bus) {
+    _eventBus = bus;
+}
+/**
+ * Get the configured event bus, or null if not configured.
+ */
+export function getGovernorEventBus() {
+    return _eventBus;
+}
+/**
+ * Publish a GovernorEvent if a bus is configured.
+ * Returns the event ID if published, null if no bus is configured.
+ */
+export async function publishGovernorEvent(event) {
+    if (!_eventBus)
+        return null;
+    try {
+        return await _eventBus.publish(event);
+    }
+    catch (err) {
+        console.error('[governor-bridge] Failed to publish event:', err);
+        return null;
+    }
+}

package/dist/src/webhook/handlers/issue-updated.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Handle Issue update events — status transition triggers.
+ *
+ * Handles:
+ * - Finished → auto-QA trigger (with circuit breaker)
+ * - → Rejected → escalation ladder (circuit breaker, decomposition, human escalation)
+ * - (Icebox|Rejected|Canceled) → Backlog → auto-development trigger (with circuit breaker)
+ * - Finished → Delivered → auto-acceptance trigger
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@renseiai/agentfactory-linear';
+import type { ResolvedWebhookConfig } from '../../types.js';
+import type { createLogger } from '@renseiai/agentfactory-server';
+export declare function handleIssueUpdated(config: ResolvedWebhookConfig, payload: LinearWebhookPayload, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=issue-updated.d.ts.map

package/dist/src/webhook/handlers/issue-updated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue-updated.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/issue-updated.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,+BAA+B,CAAA;AA6BxF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAQ3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAEjE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA81B9B"}