@agentuity/cli 1.0.59 → 2.0.0-beta.1

package/src/cmd/dev/process-manager.ts

@@ -0,0 +1,261 @@
+/**
+ * Process Manager for Dev Mode
+ *
+ * Tracks all spawned processes and ensures they're cleaned up on:
+ * - Startup failure (any server fails to start)
+ * - Runtime crash (uncaught exception)
+ * - Graceful shutdown (SIGINT/SIGTERM)
+ *
+ * This prevents orphan processes and port conflicts between dev sessions.
+ */
+
+import type { Logger } from '../../types';
+
+export interface ManagedProcess {
+	/** Process identifier for logging */
+	id: string;
+	/** The process handle */
+	process: {
+		kill: (signal?: number | NodeJS.Signals) => void;
+		exitCode: number | null;
+		pid?: number;
+	};
+	/** Human-readable description */
+	description: string;
+	/** The port this process uses (if any) */
+	port?: number;
+	/** Whether this process is critical (startup fails if it dies) */
+	critical?: boolean;
+}
+
+export interface ManagedServer {
+	/** Server identifier */
+	id: string;
+	/** The server handle */
+	server: {
+		close: () => void | Promise<void>;
+	};
+	/** Human-readable description */
+	description: string;
+	/** The port this server uses */
+	port?: number;
+}
+
+/**
+ * Process Manager
+ *
+ * Tracks all processes and servers started during dev mode and provides
+ * centralized cleanup on failure or shutdown.
+ */
+export class ProcessManager {
+	private processes: ManagedProcess[] = [];
+	private servers: ManagedServer[] = [];
+	private logger: Logger;
+	private cleaningUp = false;
+
+	constructor(logger: Logger) {
+		this.logger = logger;
+	}
+
+	/**
+	 * Register a spawned process for tracking.
+	 */
+	registerProcess(proc: ManagedProcess): void {
+		this.processes.push(proc);
+		this.logger.debug(
+			'Registered process: %s (pid=%s, port=%s)',
+			proc.id,
+			proc.process.pid ?? 'unknown',
+			proc.port ?? 'n/a'
+		);
+	}
+
+	/**
+	 * Register a server for tracking.
+	 */
+	registerServer(server: ManagedServer): void {
+		this.servers.push(server);
+		this.logger.debug('Registered server: %s (port=%s)', server.id, server.port ?? 'n/a');
+	}
+
+	/**
+	 * Unregister a process (e.g., after it exits normally).
+	 */
+	unregisterProcess(id: string): void {
+		const idx = this.processes.findIndex((p) => p.id === id);
+		if (idx !== -1) {
+			this.processes.splice(idx, 1);
+			this.logger.debug('Unregistered process: %s', id);
+		}
+	}
+
+	/**
+	 * Unregister a server.
+	 */
+	unregisterServer(id: string): void {
+		const idx = this.servers.findIndex((s) => s.id === id);
+		if (idx !== -1) {
+			this.servers.splice(idx, 1);
+			this.logger.debug('Unregistered server: %s', id);
+		}
+	}
+
+	/**
+	 * Get all registered ports (for cleanup verification).
+	 */
+	getPorts(): number[] {
+		const ports: number[] = [];
+		for (const proc of this.processes) {
+			if (proc.port) ports.push(proc.port);
+		}
+		for (const server of this.servers) {
+			if (server.port) ports.push(server.port);
+		}
+		return ports;
+	}
+
+	/**
+	 * Clean up all tracked processes and servers.
+	 *
+	 * @param reason - Why cleanup is happening (for logging)
+	 * @param timeout - Max time to wait for graceful shutdown (ms)
+	 */
+	async cleanup(reason: string, timeout = 3000): Promise<void> {
+		if (this.cleaningUp) {
+			this.logger.debug('Cleanup already in progress, skipping');
+			return;
+		}
+		this.cleaningUp = true;
+
+		this.logger.debug('Starting cleanup (reason: %s)', reason);
+
+		// Kill processes in reverse order (LIFO)
+		for (let i = this.processes.length - 1; i >= 0; i--) {
+			const proc = this.processes[i];
+			if (!proc) continue;
+
+			try {
+				if (proc.process.exitCode === null) {
+					this.logger.debug(
+						'Killing process %s (pid=%s)',
+						proc.id,
+						proc.process.pid ?? 'unknown'
+					);
+					proc.process.kill('SIGTERM');
+				}
+			} catch (err) {
+				this.logger.debug('Error killing process %s: %s', proc.id, err);
+			}
+		}
+
+		// Close servers
+		for (let i = this.servers.length - 1; i >= 0; i--) {
+			const server = this.servers[i];
+			if (!server) continue;
+
+			try {
+				this.logger.debug('Closing server %s', server.id);
+				const closePromise = server.server.close();
+				if (closePromise instanceof Promise) {
+					await Promise.race([
+						closePromise,
+						new Promise<void>((resolve) => setTimeout(resolve, 1000)),
+					]);
+				}
+			} catch (err) {
+				this.logger.debug('Error closing server %s: %s', server.id, err);
+			}
+		}
+
+		// Wait for processes to exit, then force-kill if needed
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) {
+			const allExited = this.processes.every((p) => p.process.exitCode !== null);
+			if (allExited) break;
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+
+		// Force kill any remaining
+		for (const proc of this.processes) {
+			if (proc.process.exitCode === null) {
+				try {
+					this.logger.debug('Force killing process %s', proc.id);
+					proc.process.kill('SIGKILL');
+				} catch (err) {
+					this.logger.debug('Error force killing process %s: %s', proc.id, err);
+				}
+			}
+		}
+
+		this.logger.debug('Cleanup complete');
+		this.processes = [];
+		this.servers = [];
+	}
+
+	/**
+	 * Verify that all ports used by tracked processes are released.
+	 * Used after cleanup to ensure no orphan processes remain.
+	 */
+	async verifyPortsReleased(): Promise<{ port: number; released: boolean }[]> {
+		const results: { port: number; released: boolean }[] = [];
+		const ports = this.getPorts();
+
+		for (const port of ports) {
+			const released = await this.isPortAvailable(port);
+			results.push({ port, released });
+
+			if (!released) {
+				this.logger.warn('Port %d is still in use after cleanup', port);
+			}
+		}
+
+		return results;
+	}
+
+	/**
+	 * Check if a port is available.
+	 */
+	private isPortAvailable(port: number, host = '127.0.0.1'): Promise<boolean> {
+		return new Promise((resolve) => {
+			const net = require('node:net');
+			const server = net.createServer();
+			server.once('error', () => resolve(false));
+			server.listen(port, host, () => {
+				server.close(() => resolve(true));
+			});
+		});
+	}
+}
+
+/**
+ * Global process manager instance for dev mode.
+ * Set in dev/index.ts during startup.
+ */
+let globalProcessManager: ProcessManager | null = null;
+
+/**
+ * Get the global process manager (throws if not initialized).
+ */
+export function getProcessManager(): ProcessManager {
+	if (!globalProcessManager) {
+		throw new Error('ProcessManager not initialized. Call initProcessManager first.');
+	}
+	return globalProcessManager;
+}
+
+/**
+ * Initialize the global process manager.
+ */
+export function initProcessManager(logger: Logger): ProcessManager {
+	globalProcessManager = new ProcessManager(logger);
+	return globalProcessManager;
+}
+
+/**
+ * Cleanup helper that can be called from signal handlers or error handlers.
+ */
+export async function cleanupAll(reason: string): Promise<void> {
+	if (globalProcessManager) {
+		await globalProcessManager.cleanup(reason);
+	}
+}

package/src/errors.ts

@@ -1,51 +1,22 @@
 import type { Logger } from './types';
 
 /**
- * Standard exit codes for the CLI.
- *
- * Values start at 10 to avoid collisions with Unix signal numbers (1-9)
- * and shell conventions (e.g. 2 = misuse of builtins, 9 = SIGKILL/OOM).
- * Range 10-125 is safe — below shell-reserved 126-128 and signal-death
- * codes 128+N.
- *
- * 0 and 1 are kept as universal success/failure codes.
+ * Standard exit codes for the CLI
  */
 export enum ExitCode {
 	SUCCESS = 0,
 	GENERAL_ERROR = 1,
-	VALIDATION_ERROR = 10,
-	AUTH_ERROR = 11,
-	NOT_FOUND = 12,
-	PERMISSION_ERROR = 13,
-	NETWORK_ERROR = 14,
-	FILE_ERROR = 15,
-	USER_CANCELLED = 16,
-	BUILD_FAILED = 17,
-	SECURITY_ERROR = 18,
-	PAYMENT_REQUIRED = 19,
-	UPGRADE_REQUIRED = 20,
+	VALIDATION_ERROR = 2,
+	AUTH_ERROR = 3,
+	NOT_FOUND = 4,
+	PERMISSION_ERROR = 5,
+	NETWORK_ERROR = 6,
+	FILE_ERROR = 7,
+	USER_CANCELLED = 8,
+	BUILD_FAILED = 9,
+	SECURITY_ERROR = 10,
 }
 
-/**
- * Human-readable descriptions for each exit code.
- * This is the single source of truth consumed by the schema generator and AI help.
- */
-export const exitCodeDescriptions: Record<number, string> = {
-	[ExitCode.SUCCESS]: 'Success',
-	[ExitCode.GENERAL_ERROR]: 'General error',
-	[ExitCode.VALIDATION_ERROR]: 'Validation error (invalid arguments or options)',
-	[ExitCode.AUTH_ERROR]: 'Authentication error (login required or credentials invalid)',
-	[ExitCode.NOT_FOUND]: 'Resource not found (project, file, deployment, etc.)',
-	[ExitCode.PERMISSION_ERROR]: 'Permission denied (insufficient access rights)',
-	[ExitCode.NETWORK_ERROR]: 'Network error (API unreachable or timeout)',
-	[ExitCode.FILE_ERROR]: 'File system error (file read/write failed)',
-	[ExitCode.USER_CANCELLED]: 'User cancelled (operation aborted by user)',
-	[ExitCode.BUILD_FAILED]: 'Build failed',
-	[ExitCode.SECURITY_ERROR]: 'Security error (malware detected)',
-	[ExitCode.PAYMENT_REQUIRED]: 'Payment required (plan upgrade needed)',
-	[ExitCode.UPGRADE_REQUIRED]: 'Upgrade required (CLI version too old)',
-};
-
 /**
  * Standard error codes for the CLI
  */
@@ -181,11 +152,7 @@ export function getExitCode(errorCode: ErrorCode): ExitCode {
 
 		// Payment required - user needs to upgrade their plan
 		case ErrorCode.PAYMENT_REQUIRED:
-			return ExitCode.PAYMENT_REQUIRED;
-
-		// Upgrade required - CLI version too old
-		case ErrorCode.UPGRADE_REQUIRED:
-			return ExitCode.UPGRADE_REQUIRED;
+			return ExitCode.GENERAL_ERROR;
 
 		// Resource conflicts and other errors
 		case ErrorCode.RESOURCE_ALREADY_EXISTS:
@@ -195,6 +162,7 @@ export function getExitCode(errorCode: ErrorCode): ExitCode {
 		case ErrorCode.RUNTIME_ERROR:
 		case ErrorCode.INTERNAL_ERROR:
 		case ErrorCode.NOT_IMPLEMENTED:
+		case ErrorCode.UPGRADE_REQUIRED:
 		default:
 			return ExitCode.GENERAL_ERROR;
 	}

package/src/schema-generator.ts

@@ -1,6 +1,5 @@
 import type { Command } from 'commander';
 import type { CommandDefinition, SubcommandDefinition, CommandSchemas } from './types';
-import { exitCodeDescriptions } from './errors';
 import { parseArgsSchema, parseOptionsSchema } from './schema-parser';
 import * as z from 'zod';
 
@@ -314,7 +313,18 @@ export function generateCLISchema(
 		name: 'agentuity',
 		version,
 		description: 'Agentuity CLI',
-		exitCodes: { ...exitCodeDescriptions },
+		exitCodes: {
+			0: 'Success',
+			1: 'General error',
+			2: 'Validation error (invalid arguments or options)',
+			3: 'Authentication error (login required or credentials invalid)',
+			4: 'Resource not found (project, file, deployment, etc.)',
+			5: 'Permission denied (insufficient access rights)',
+			6: 'Network error (API unreachable or timeout)',
+			7: 'File system error (file read/write failed)',
+			8: 'User cancelled (operation aborted by user)',
+			9: 'Build failed',
+		},
 		globalOptions: [
 			{
 				name: 'config',

package/src/tui.ts

@@ -25,12 +25,6 @@ function ensureCursorRestoration(): void {
 	exitHandlerInstalled = true;
 
 	const restoreCursor = () => {
-		// Only write ANSI escape sequences when stderr is a real terminal.
-		// Writing to non-TTY streams (pipes, command substitution, etc.)
-		// pollutes captured output with invisible control characters.
-		if (!process.stderr.isTTY) {
-			return;
-		}
 		// Skip cursor restoration in CI - terminals don't support these sequences
 		if (process.env.CI) {
 			return;
@@ -299,13 +293,8 @@ export function getSeverityColor(severity: string): (text: string) => string {
 export function success(message: string): void {
 	const color = getColor('success');
 	const reset = getColor('reset');
-	if (process.stderr.isTTY) {
-		// Clear line first to ensure no leftover content from previous output
-		process.stderr.write(`\r\x1b[2K${color}${ICONS.success} ${message}${reset}\n`);
-	} else {
-		// No ANSI control sequences for non-TTY streams (pipes, command substitution)
-		process.stderr.write(`${ICONS.success} ${message}\n`);
-	}
+	// Clear line first to ensure no leftover content from previous output
+	process.stderr.write(`\r\x1b[2K${color}${ICONS.success} ${message}${reset}\n`);
 }
 
 /**
@@ -1254,11 +1243,9 @@ export async function spinner<T>(
 	const outputOptions = getOutputOptions();
 	const noProgress = outputOptions ? shouldDisableProgress(outputOptions) : false;
 
-	// If stderr is not a real terminal or progress disabled, just execute
-	// the callback without animation. We check stderr specifically because
-	// the spinner writes ANSI sequences to stderr — isTTYLike() may return
-	// true when stdout is a TTY but stderr is piped (e.g. 2>&1 in $()).
-	if (!process.stderr.isTTY || noProgress) {
+	// If no interactive TTY-like environment or progress disabled, just execute
+	// the callback without animation
+	if (!isTTYLike() || noProgress) {
 		try {
 			const result =
 				options.type === 'progress'

package/src/utils/version-mismatch.ts

@@ -0,0 +1,204 @@
+/**
+ * Version mismatch detection for @agentuity/* packages.
+ *
+ * Detects when a project uses outdated v1 SDK packages while the CLI is v2,
+ * and recommends running the migration tool.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getVersion } from '../version';
+import type { Logger } from '../types';
+
+export interface VersionInfo {
+	name: string;
+	version: string;
+	major: number;
+}
+
+export interface VersionMismatchResult {
+	/** CLI major version */
+	cliMajor: number;
+	/** All @agentuity/* packages found */
+	packages: VersionInfo[];
+	/** Packages with major version mismatch */
+	mismatched: VersionInfo[];
+	/** Packages that are v1 when CLI is v2+ */
+	outdated: VersionInfo[];
+	/** Whether any v1 packages were found */
+	hasV1Packages: boolean;
+	/** Whether there are major version mismatches across packages */
+	hasMajorMismatches: boolean;
+}
+
+/**
+ * Extract major version from semver string
+ */
+function extractMajor(version: string): number {
+	// Handle ranges like ^1.0.0, ~2.0.0, >=1.0.0
+	const match = version.match(/(\d+)\.\d+\.\d+/);
+	if (match?.[1]) {
+		return parseInt(match[1], 10);
+	}
+	// Handle "latest" or "*"
+	if (version === 'latest' || version === '*') {
+		return 0; // Unknown major
+	}
+	return 0;
+}
+
+/**
+ * Get installed version from node_modules
+ */
+function getInstalledVersion(projectDir: string, packageName: string): string | null {
+	try {
+		const pkgPath = join(projectDir, 'node_modules', packageName, 'package.json');
+		if (!existsSync(pkgPath)) {
+			return null;
+		}
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+		return pkg.version || null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Detect version mismatches in @agentuity/* packages.
+ *
+ * @param projectDir - Root directory of the user's project
+ * @param logger - Logger instance
+ * @returns Version mismatch detection result
+ */
+export function detectVersionMismatch(projectDir: string, logger: Logger): VersionMismatchResult {
+	const cliVersion = getVersion();
+	const cliMajor = extractMajor(cliVersion);
+
+	const result: VersionMismatchResult = {
+		cliMajor,
+		packages: [],
+		mismatched: [],
+		outdated: [],
+		hasV1Packages: false,
+		hasMajorMismatches: false,
+	};
+
+	// Skip check for canary versions
+	if (cliVersion.includes('-')) {
+		logger.debug('Skipping version mismatch check for canary version: %s', cliVersion);
+		return result;
+	}
+
+	// Read package.json
+	const packageJsonPath = join(projectDir, 'package.json');
+	if (!existsSync(packageJsonPath)) {
+		logger.debug('No package.json found, skipping version mismatch check');
+		return result;
+	}
+
+	let packageJson: {
+		dependencies?: Record<string, string>;
+		devDependencies?: Record<string, string>;
+	};
+	try {
+		packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+	} catch (error) {
+		logger.debug('Failed to read package.json: %s', error);
+		return result;
+	}
+
+	// Collect all @agentuity/* packages
+	const allDeps = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+	};
+
+	const agentuitPackages = Object.entries(allDeps)
+		.filter(([name]) => name.startsWith('@agentuity/'))
+		.map(([name, specifier]) => ({ name, specifier }));
+
+	if (agentuitPackages.length === 0) {
+		logger.debug('No @agentuity/* packages found in package.json');
+		return result;
+	}
+
+	// Check each package's installed version
+	for (const { name } of agentuitPackages) {
+		const installedVersion = getInstalledVersion(projectDir, name);
+		if (!installedVersion) {
+			logger.debug('%s: not installed, skipping', name);
+			continue;
+		}
+
+		const major = extractMajor(installedVersion);
+		const info: VersionInfo = {
+			name,
+			version: installedVersion,
+			major,
+		};
+
+		result.packages.push(info);
+
+		// Check if this is a v1 package when CLI is v2+
+		if (major === 1 && cliMajor >= 2) {
+			result.outdated.push(info);
+			result.hasV1Packages = true;
+		}
+	}
+
+	// Check for major version mismatches across installed packages
+	if (result.packages.length > 1) {
+		const majors = new Set(result.packages.map((p) => p.major));
+		if (majors.size > 1) {
+			result.hasMajorMismatches = true;
+			// Find packages that don't match the most common major version
+			const majorCounts = new Map<number, number>();
+			for (const pkg of result.packages) {
+				majorCounts.set(pkg.major, (majorCounts.get(pkg.major) || 0) + 1);
+			}
+			const mostCommonMajor =
+				[...majorCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] || cliMajor;
+
+			for (const pkg of result.packages) {
+				if (pkg.major !== mostCommonMajor) {
+					result.mismatched.push(pkg);
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Format a warning message for version mismatches.
+ */
+export function formatVersionMismatchWarning(result: VersionMismatchResult): string {
+	const lines: string[] = [];
+
+	if (result.hasV1Packages) {
+		lines.push('You are using Agentuity SDK v1 packages, but v2 is now available.');
+		lines.push('');
+		lines.push('  Outdated packages:');
+		for (const pkg of result.outdated) {
+			lines.push(`    • ${pkg.name}@${pkg.version}`);
+		}
+		lines.push('');
+		lines.push('  → Run `npx @agentuity/migrate` to upgrade your project to v2.');
+		lines.push('    This will automatically update your code and dependencies.');
+		lines.push('');
+		lines.push('  See the migration guide: https://docs.agentuity.com/migration/v1-to-v2');
+	} else if (result.hasMajorMismatches) {
+		lines.push('Your project has mismatched major versions across @agentuity/* packages.');
+		lines.push('');
+		lines.push('  Packages:');
+		for (const pkg of result.packages) {
+			const marker = result.mismatched.includes(pkg) ? ' ⚠️' : '';
+			lines.push(`    • ${pkg.name}@${pkg.version} (v${pkg.major})${marker}`);
+		}
+		lines.push('');
+		lines.push('  → Run `bun install` to sync versions, or pin to the same major version.');
+	}
+
+	return lines.join('\n');
+}

package/dist/cmd/build/ast.d.ts

@@ -1,78 +0,0 @@
-import type { BuildMetadata } from '../../types';
-import { type WorkbenchConfig } from '@agentuity/core';
-export declare function getDevmodeDeploymentId(projectId: string, endpointId: string): string;
-export declare function parseEvalMetadata(rootDir: string, filename: string, contents: string, projectId: string, deploymentId: string, agentId?: string, agentMetadata?: Map<string, Map<string, string>>): Promise<[
-    string,
-    Array<{
-        filename: string;
-        id: string;
-        version: string;
-        name: string;
-        evalId: string;
-        description?: string;
-    }>
-]>;
-export declare function parseAgentMetadata(rootDir: string, filename: string, contents: string, projectId: string, deploymentId: string): Promise<[string, Map<string, string>] | undefined>;
-export interface ParseRouteOptions {
-    visitedFiles?: Set<string>;
-    mountedSubrouters?: Set<string>;
-    /**
-     * Explicit mount prefix for this router file, derived from code-based routing
-     * (e.g., from `createApp({ router })` or `.route()` calls).
-     * When provided, overrides the filesystem-derived mount path.
-     */
-    mountPrefix?: string;
-}
-export declare function parseRoute(rootDir: string, filename: string, projectId: string, deploymentId: string, visitedFilesOrOptions?: Set<string> | ParseRouteOptions, mountedSubrouters?: Set<string>): Promise<BuildMetadata['routes']>;
-/**
- * Result of workbench analysis
- */
-export interface WorkbenchAnalysis {
-    hasWorkbench: boolean;
-    config: WorkbenchConfig | null;
-}
-/**
- * Check if a TypeScript file actively uses a specific function
- * (ignores comments and unused imports)
- *
- * @param content - The TypeScript source code
- * @param functionName - The function name to check for (e.g., 'createWorkbench')
- * @returns true if the function is both imported and called
- */
-export declare function checkFunctionUsage(content: string, functionName: string): boolean;
-/**
- * Check if app.ts contains conflicting routes for a given endpoint
- */
-export declare function checkRouteConflicts(content: string, workbenchEndpoint: string): boolean;
-/**
- * Extract AppState type from setup() return value in createApp call
- *
- * @param content - The TypeScript source code from app.ts
- * @returns Type definition string or null if no setup found
- */
-export declare function extractAppStateType(content: string): string | null;
-/**
- * Generate lifecycle type files (src/generated/state.ts and src/generated/router.ts)
- *
- * @param rootDir - Root directory of the project
- * @param outDir - Output directory (typically src/generated/)
- * @param appFilePath - Path to app.ts file
- * @returns true if files were generated, false if no setup found
- */
-export declare function generateLifecycleTypes(rootDir: string, outDir: string, appFilePath: string): Promise<boolean>;
-/**
- * Analyze workbench usage and extract configuration
- *
- * @param content - The TypeScript source code
- * @returns workbench analysis including usage and config
- */
-export declare function analyzeWorkbench(content: string): WorkbenchAnalysis;
-/**
- * Find the end position of createApp call statement in the source code
- * Uses AST parsing to reliably find the complete statement including await/const assignment
- *
- * @param content - The source code content
- * @returns The character position after the createApp statement, or -1 if not found
- */
-export declare function findCreateAppEndPosition(content: string): number;
-//# sourceMappingURL=ast.d.ts.map

package/dist/cmd/build/ast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../../src/cmd/build/ast.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAqIxE,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpF;AAoTD,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC9C,OAAO,CACT;IACC,MAAM;IACN,KAAK,CAAC;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACF,CACD,CAyNA;AAID,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GAClB,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAqPpD;AA4pBD,MAAM,WAAW,iBAAiB;IACjC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,UAAU,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,iBAAiB,EACvD,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC7B,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAo+BlC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAoCjF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CA+BvF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgOlE;AAkED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GACjB,OAAO,CAAC,OAAO,CAAC,CA8LlB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAsLnE;AA+BD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA0EhE"}