@vertaaux/cli 0.2.0

package/dist/commands/policy.js

@@ -0,0 +1,347 @@
+/**
+ * Policy management commands for VertaaUX CLI.
+ *
+ * Provides commands to initialize, validate, and display policy files.
+ *
+ * Implements CICD-17: Policy-as-code support.
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "yaml";
+import chalk from "chalk";
+import { loadPolicy, loadPolicyFile, resolveBranchPolicy, POLICY_TEMPLATES, policyJsonSchema, PolicyValidationError, PolicyLoadError, } from "../policy/index.js";
+import { ExitCode } from "../utils/exit-codes.js";
+import { writeJsonOutput, writeOutput } from "../output/envelope.js";
+import { resolveCommandFormat } from "../output/formats.js";
+/**
+ * Default policy file path.
+ */
+const DEFAULT_POLICY_FILE = "vertaa.policy.yml";
+/**
+ * Generate a policy file with comments.
+ */
+function generatePolicyYaml(template) {
+    const policy = POLICY_TEMPLATES[template];
+    const assertions = policy.assertions;
+    // Build YAML with helpful comments
+    const lines = [
+        "# VertaaUX Policy Configuration",
+        "# https://vertaaux.ai/docs/policy",
+        "",
+        "# JSON Schema for IDE validation",
+        "$schema: https://vertaaux.ai/schemas/policy.json",
+        "",
+        `# Policy format version`,
+        `version: ${policy.version}`,
+        "",
+    ];
+    if (policy.name) {
+        lines.push(`# Human-readable policy name`);
+        lines.push(`name: "${policy.name}"`);
+        lines.push("");
+    }
+    if (policy.description) {
+        lines.push(`# Policy description`);
+        lines.push(`description: "${policy.description}"`);
+        lines.push("");
+    }
+    // Assertions section
+    lines.push("# Quality gate assertions");
+    lines.push("# All assertions must pass for the build to succeed");
+    lines.push("assertions:");
+    if (assertions.fail_on) {
+        lines.push(`  # Fail on issues at or above this severity: error|warning|info`);
+        lines.push(`  fail_on: ${assertions.fail_on}`);
+    }
+    if (assertions.overall_score !== undefined) {
+        lines.push(`  # Minimum overall score (0-100)`);
+        lines.push(`  overall_score: ${assertions.overall_score}`);
+    }
+    if (assertions.max_new_errors !== undefined) {
+        lines.push(`  # Maximum new error-severity issues allowed`);
+        lines.push(`  max_new_errors: ${assertions.max_new_errors}`);
+    }
+    if (assertions.max_new_warnings !== undefined) {
+        lines.push(`  # Maximum new warning-severity issues allowed`);
+        lines.push(`  max_new_warnings: ${assertions.max_new_warnings}`);
+    }
+    lines.push("");
+    // Branches section (if present)
+    const branches = policy.branches;
+    if (branches) {
+        lines.push("# Branch-specific policy overrides");
+        lines.push("# Use stricter rules for protected branches");
+        lines.push("branches:");
+        for (const [branchKey, branchConfig] of Object.entries(branches)) {
+            lines.push(`  ${branchKey}:`);
+            if (branchConfig.pattern) {
+                lines.push(`    pattern: "${branchConfig.pattern}"`);
+            }
+            if (branchConfig.assertions) {
+                lines.push("    assertions:");
+                for (const [key, value] of Object.entries(branchConfig.assertions)) {
+                    lines.push(`      ${key}: ${value}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    // Bypass labels
+    if (policy.bypass_labels) {
+        lines.push("# PR labels that bypass quality gate entirely");
+        lines.push("# Use sparingly for genuine emergencies");
+        lines.push("bypass_labels:");
+        for (const label of policy.bypass_labels) {
+            lines.push(`  - "${label}"`);
+        }
+        lines.push("");
+    }
+    // Rule overrides placeholder
+    lines.push("# Rule-specific overrides (uncomment to customize)");
+    lines.push("# rules:");
+    lines.push("#   color-contrast:");
+    lines.push("#     severity: warning  # Downgrade from error");
+    lines.push('#     reason: "Using brand colors, manually verified"');
+    lines.push("#   image-alt:");
+    lines.push("#     severity: ignore  # Handled by CMS");
+    lines.push("#     paths:");
+    lines.push('#       - "src/components/cms/**"');
+    lines.push("");
+    // Exclude paths placeholder
+    lines.push("# Paths to exclude from auditing (uncomment to customize)");
+    lines.push("# exclude_paths:");
+    lines.push('#   - "src/legacy/**"');
+    lines.push('#   - "vendor/**"');
+    return lines.join("\n");
+}
+/**
+ * Initialize a new policy file.
+ */
+async function initPolicy(options) {
+    const template = options.template || "basic";
+    const outputPath = options.output || DEFAULT_POLICY_FILE;
+    const absolutePath = path.resolve(process.cwd(), outputPath);
+    // Check if file exists
+    if (fs.existsSync(absolutePath) && !options.force) {
+        console.error(chalk.red(`Policy file already exists: ${absolutePath}`));
+        console.error(chalk.dim("Use --force to overwrite."));
+        process.exit(ExitCode.ERROR);
+    }
+    // Validate template
+    if (!POLICY_TEMPLATES[template]) {
+        console.error(chalk.red(`Unknown template: ${template}`));
+        console.error(chalk.dim(`Available templates: ${Object.keys(POLICY_TEMPLATES).join(", ")}`));
+        process.exit(ExitCode.ERROR);
+    }
+    // Generate policy
+    const policyYaml = generatePolicyYaml(template);
+    // Write file
+    fs.writeFileSync(absolutePath, policyYaml, "utf-8");
+    console.error(chalk.green(`Created policy file: ${absolutePath}`));
+    console.error(chalk.dim(`Template: ${template}`));
+    console.error("");
+    console.error("Next steps:");
+    console.error(`  1. Review and customize ${outputPath}`);
+    console.error("  2. Commit the file to your repository");
+    console.error("  3. Run 'vertaa policy validate' to verify");
+}
+/**
+ * Validate a policy file.
+ */
+async function validatePolicyCommand(filePath, options) {
+    const quiet = options.quiet ?? false;
+    try {
+        // Load policy from path or search
+        let policy;
+        let policyPath;
+        if (filePath) {
+            policy = await loadPolicyFile(filePath);
+            policyPath = filePath;
+        }
+        else {
+            const result = await loadPolicy();
+            policy = result.policy;
+            policyPath = result.path;
+        }
+        if (!policyPath) {
+            console.error(chalk.yellow("No policy file found. Using defaults."));
+            console.error(chalk.dim("Create a policy file with: vertaa policy init"));
+            return;
+        }
+        // Validation passed if we got here
+        if (!quiet) {
+            console.error(chalk.green(`Policy file valid: ${policyPath}`));
+            console.error("");
+            console.error("Summary:");
+            console.error(`  Version: ${policy.version}`);
+            console.error(`  Name: ${policy.name || "(unnamed)"}`);
+            if (policy.assertions) {
+                console.error("  Assertions:");
+                if (policy.assertions.fail_on) {
+                    console.error(`    - Fail on: ${policy.assertions.fail_on}`);
+                }
+                if (policy.assertions.overall_score !== undefined) {
+                    console.error(`    - Overall score >= ${policy.assertions.overall_score}`);
+                }
+                if (policy.assertions.max_new_errors !== undefined) {
+                    console.error(`    - Max new errors: ${policy.assertions.max_new_errors}`);
+                }
+            }
+            if (policy.branches) {
+                console.error(`  Branches: ${Object.keys(policy.branches).join(", ")}`);
+            }
+            if (policy.rules) {
+                console.error(`  Rule overrides: ${Object.keys(policy.rules).length}`);
+            }
+            if (policy.bypass_labels?.length) {
+                console.error(`  Bypass labels: ${policy.bypass_labels.join(", ")}`);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof PolicyValidationError) {
+            console.error(chalk.red("Policy validation failed:"));
+            for (const err of error.errors) {
+                console.error(chalk.red(`  - ${err}`));
+            }
+            process.exit(ExitCode.ERROR);
+        }
+        if (error instanceof PolicyLoadError) {
+            console.error(chalk.red(`Failed to load policy: ${error.message}`));
+            process.exit(ExitCode.ERROR);
+        }
+        throw error;
+    }
+}
+/**
+ * Show effective policy for a branch.
+ */
+async function showPolicy(options) {
+    const branch = options.branch || "";
+    const format = options.format || "yaml";
+    try {
+        // Load policy
+        let policy;
+        let policyPath;
+        if (options.policy) {
+            policy = await loadPolicyFile(options.policy);
+            policyPath = options.policy;
+        }
+        else {
+            const result = await loadPolicy();
+            policy = result.policy;
+            policyPath = result.path;
+        }
+        // Resolve branch-specific overrides
+        let effectivePolicy = policy;
+        let branchInfo = "";
+        if (branch) {
+            effectivePolicy = resolveBranchPolicy(policy, branch);
+            branchInfo = ` (branch: ${branch})`;
+        }
+        // Output
+        if (policyPath) {
+            console.error(chalk.dim(`Policy: ${policyPath}${branchInfo}`));
+            console.error("");
+        }
+        else {
+            console.error(chalk.dim(`Using default policy${branchInfo}`));
+            console.error("");
+        }
+        if (format === "json") {
+            writeJsonOutput(effectivePolicy, "policy-show");
+        }
+        else {
+            // YAML output
+            const yamlOutput = yaml.stringify(effectivePolicy, {
+                indent: 2,
+                lineWidth: 100,
+            });
+            writeOutput(yamlOutput);
+        }
+    }
+    catch (error) {
+        if (error instanceof PolicyValidationError) {
+            console.error(chalk.red("Policy validation failed:"));
+            for (const err of error.errors) {
+                console.error(chalk.red(`  - ${err}`));
+            }
+            process.exit(ExitCode.ERROR);
+        }
+        if (error instanceof PolicyLoadError) {
+            console.error(chalk.red(`Failed to load policy: ${error.message}`));
+            process.exit(ExitCode.ERROR);
+        }
+        throw error;
+    }
+}
+/**
+ * Output JSON Schema for policy file.
+ */
+function outputSchema() {
+    writeJsonOutput(policyJsonSchema, "policy-schema");
+}
+/**
+ * Register the policy command with the Commander program.
+ */
+export function registerPolicyCommand(program) {
+    const policyCmd = program
+        .command("policy")
+        .description("Manage policy-as-code configuration");
+    // policy init
+    policyCmd
+        .command("init")
+        .description("Create a new policy file")
+        .option("-t, --template <template>", "Policy template: basic|strict|lenient", "basic")
+        .option("-o, --output <path>", "Output file path", DEFAULT_POLICY_FILE)
+        .option("-f, --force", "Overwrite existing file")
+        .action(async (options) => {
+        try {
+            await initPolicy(options);
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+    // policy validate
+    policyCmd
+        .command("validate [file]")
+        .description("Validate a policy file")
+        .option("-q, --quiet", "Suppress output on success")
+        .action(async (filePath, options) => {
+        try {
+            await validatePolicyCommand(filePath, options);
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+    // policy show
+    policyCmd
+        .command("show")
+        .description("Display effective policy for a branch")
+        .option("-b, --branch <name>", "Branch to show policy for")
+        .option("-f, --format <format>", "Output format: yaml|json", "yaml")
+        .option("-p, --policy <path>", "Path to policy file")
+        .action(async (options, cmd) => {
+        try {
+            // Validate format using per-command registry
+            const machineMode = cmd.optsWithGlobals?.().machine || false;
+            const validatedFormat = resolveCommandFormat("policy-show", options.format, machineMode);
+            await showPolicy({ ...options, format: validatedFormat });
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+    // policy schema
+    policyCmd
+        .command("schema")
+        .description("Output JSON Schema for policy file validation")
+        .action(() => {
+        outputSchema();
+    });
+}

package/dist/commands/upload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Upload command for VertaaUX CLI.
+ *
+ * Syncs local audit results to VertaaUX cloud.
+ * Enables sharing results across team members and CI runs.
+ */
+import { Command } from "commander";
+/**
+ * Register the upload command with the Commander program.
+ */
+export declare function registerUploadCommand(program: Command): void;
+//# sourceMappingURL=upload.d.ts.map

package/dist/commands/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyLpC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB5D"}

package/dist/commands/upload.js

@@ -0,0 +1,158 @@
+/**
+ * Upload command for VertaaUX CLI.
+ *
+ * Syncs local audit results to VertaaUX cloud.
+ * Enables sharing results across team members and CI runs.
+ */
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { loadToken } from "../auth/token-store.js";
+import { getCIToken } from "../auth/ci-token.js";
+import { resolveApiBase } from "../utils/client.js";
+import { resolveConfig } from "../config/loader.js";
+import { loadBaseline, DEFAULT_BASELINE_PATH } from "../baseline/manager.js";
+import { ExitCode } from "../utils/exit-codes.js";
+/**
+ * Artifacts directory.
+ */
+const ARTIFACTS_DIR = ".vertaaux/artifacts";
+/**
+ * Get authentication token from stored credentials or environment.
+ */
+async function getAuthToken() {
+    // Check stored token first
+    const storedToken = await loadToken();
+    if (storedToken?.accessToken) {
+        return storedToken.accessToken;
+    }
+    // Check environment
+    return getCIToken();
+}
+/**
+ * Handle the upload command.
+ */
+async function handleUpload(jobId, options) {
+    // Get auth token
+    const token = await getAuthToken();
+    if (!token) {
+        console.error(chalk.red("Error: Not authenticated."));
+        console.error("Run `vertaa login` to authenticate or set VERTAAUX_TOKEN environment variable.");
+        process.exit(ExitCode.ERROR);
+    }
+    // Load config for API base (supports --config global option)
+    const config = await resolveConfig(options.configPath);
+    const apiBase = resolveApiBase(options.base);
+    // Determine what to upload
+    const spinner = ora("Preparing upload...").start();
+    try {
+        // If no job ID, find the most recent local result
+        let targetJobId = jobId;
+        let localResultPath;
+        if (!targetJobId) {
+            // Look for recent results in artifacts directory
+            const artifactsPath = path.resolve(process.cwd(), ARTIFACTS_DIR);
+            if (fs.existsSync(artifactsPath)) {
+                const dirs = fs.readdirSync(artifactsPath).filter((d) => {
+                    const stat = fs.statSync(path.join(artifactsPath, d));
+                    return stat.isDirectory();
+                });
+                if (dirs.length > 0) {
+                    // Get most recent by mtime
+                    const sorted = dirs
+                        .map((d) => ({
+                        name: d,
+                        mtime: fs.statSync(path.join(artifactsPath, d)).mtime,
+                    }))
+                        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+                    targetJobId = sorted[0].name;
+                    localResultPath = path.join(artifactsPath, targetJobId);
+                }
+            }
+            if (!targetJobId) {
+                spinner.fail("No job ID provided and no local results found.");
+                console.error("Run `vertaa audit --save-trace` to save local results first.");
+                process.exit(ExitCode.ERROR);
+            }
+        }
+        spinner.text = `Uploading audit ${targetJobId}...`;
+        // Prepare upload payload
+        const payload = {
+            job_id: targetJobId,
+            project: options.project || path.basename(process.cwd()),
+        };
+        // Add local results if available
+        if (localResultPath && fs.existsSync(localResultPath)) {
+            const files = fs.readdirSync(localResultPath);
+            const artifacts = {};
+            for (const file of files) {
+                const filePath = path.join(localResultPath, file);
+                const stat = fs.statSync(filePath);
+                // Skip large files (> 10MB)
+                if (stat.size > 10 * 1024 * 1024) {
+                    continue;
+                }
+                // Read file content (base64 for binary)
+                const content = fs.readFileSync(filePath);
+                const ext = path.extname(file).toLowerCase();
+                const isBinary = [".png", ".jpg", ".jpeg", ".gif", ".zip"].includes(ext);
+                artifacts[file] = isBinary
+                    ? content.toString("base64")
+                    : content.toString("utf-8");
+            }
+            payload.artifacts = artifacts;
+        }
+        // Upload baseline if requested
+        if (options.baseline) {
+            const baseline = await loadBaseline(DEFAULT_BASELINE_PATH);
+            if (baseline) {
+                payload.baseline = baseline;
+                spinner.text = `Uploading audit ${targetJobId} with baseline...`;
+            }
+        }
+        // Make API request
+        const response = await fetch(`${apiBase}/sync/upload`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-API-Key": token,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: { message: response.statusText } }));
+            throw new Error(error.error?.message || `HTTP ${response.status}`);
+        }
+        const result = (await response.json());
+        if (!result.success) {
+            throw new Error(result.error?.message || "Upload failed");
+        }
+        spinner.succeed("Upload complete!");
+        console.error("");
+        console.error(`  Job ID: ${result.job_id}`);
+        console.error(`  URL:    ${chalk.cyan(result.url)}`);
+        console.error("");
+        console.error("Share this URL with your team to view the results.");
+    }
+    catch (error) {
+        spinner.fail("Upload failed");
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+        process.exit(ExitCode.ERROR);
+    }
+}
+/**
+ * Register the upload command with the Commander program.
+ */
+export function registerUploadCommand(program) {
+    program
+        .command("upload [job-id]")
+        .description("Upload audit results to VertaaUX cloud")
+        .option("--baseline", "Also upload baseline file")
+        .option("--project <name>", "Cloud project name (default: current directory name)")
+        .option("-b, --base <url>", "API base URL")
+        .action(async (jobId, options, command) => {
+        const globalOpts = command.optsWithGlobals();
+        await handleUpload(jobId, { ...options, configPath: globalOpts.config });
+    });
+}

package/dist/config/defaults.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Default configuration values for VertaaUX CLI.
+ *
+ * These defaults are merged with config file values, with the config file
+ * taking precedence. CLI flags override both.
+ *
+ * Precedence: CLI flags > env vars > config file > defaults
+ */
+import type { VertaauxConfig } from "./schema.js";
+/**
+ * Default configuration values.
+ */
+export declare const DEFAULT_CONFIG: Required<Pick<VertaauxConfig, "mode" | "output" | "baseline" | "timeout" | "interval">> & {
+    ci: NonNullable<VertaauxConfig["ci"]>;
+};
+/**
+ * Deep merge two config objects.
+ * Target values take precedence over defaults.
+ */
+export declare function mergeWithDefaults(config: VertaauxConfig): VertaauxConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/config/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CACnC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC,CAC9E,GAAG;IACF,EAAE,EAAE,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;CAgBvC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAiBxE"}

package/dist/config/defaults.js

@@ -0,0 +1,49 @@
+/**
+ * Default configuration values for VertaaUX CLI.
+ *
+ * These defaults are merged with config file values, with the config file
+ * taking precedence. CLI flags override both.
+ *
+ * Precedence: CLI flags > env vars > config file > defaults
+ */
+/**
+ * Default configuration values.
+ */
+export const DEFAULT_CONFIG = {
+    mode: "basic",
+    output: {
+        format: "auto",
+        groupBy: "severity",
+    },
+    baseline: {
+        path: ".vertaaux/baseline.json",
+        autoUpdate: false,
+    },
+    ci: {
+        template: "none",
+    },
+    timeout: 60000,
+    interval: 5000,
+};
+/**
+ * Deep merge two config objects.
+ * Target values take precedence over defaults.
+ */
+export function mergeWithDefaults(config) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...config,
+        output: {
+            ...DEFAULT_CONFIG.output,
+            ...config.output,
+        },
+        baseline: {
+            ...DEFAULT_CONFIG.baseline,
+            ...config.baseline,
+        },
+        ci: {
+            ...DEFAULT_CONFIG.ci,
+            ...config.ci,
+        },
+    };
+}

package/dist/config/loader.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Configuration loader using cosmiconfig with Ajv validation.
+ *
+ * Searches for configuration in multiple formats:
+ * - .vertaaux.yml / .vertaaux.yaml
+ * - .vertaaux.json
+ * - vertaaux.config.js / vertaaux.config.mjs
+ * - package.json (vertaaux key)
+ *
+ * Validates against JSON Schema and merges with defaults.
+ */
+import { type ErrorObject } from "ajv";
+import type { VertaauxConfig } from "./schema.js";
+/**
+ * Error thrown when config validation fails.
+ */
+export declare class ConfigValidationError extends Error {
+    readonly errors: ErrorObject[] | null | undefined;
+    constructor(errors: ErrorObject[] | null | undefined, filePath?: string);
+}
+/**
+ * Error thrown when config file cannot be loaded.
+ */
+export declare class ConfigLoadError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Load configuration from file and environment.
+ *
+ * Searches for config file starting from current working directory
+ * and walking up the directory tree.
+ *
+ * @param searchFrom - Directory to start search from (defaults to cwd)
+ * @returns Merged configuration with defaults
+ *
+ * @example
+ * ```typescript
+ * const config = await loadConfig();
+ * console.log(config.mode); // 'basic' (default or from config)
+ * ```
+ */
+export declare function loadConfig(searchFrom?: string): Promise<VertaauxConfig>;
+/**
+ * Load configuration from a specific file path.
+ *
+ * @param filePath - Path to config file
+ * @returns Merged configuration with defaults
+ */
+export declare function loadConfigFile(filePath: string): Promise<VertaauxConfig>;
+/**
+ * Resolve configuration from explicit path or auto-detection.
+ *
+ * If an explicit path is provided, loads that file directly.
+ * Otherwise, falls back to cosmiconfig auto-detection.
+ *
+ * @param explicitPath - Optional explicit config file path (from --config flag)
+ * @returns Merged configuration with defaults
+ */
+export declare function resolveConfig(explicitPath?: string): Promise<VertaauxConfig>;
+/**
+ * Clear the config cache.
+ * Useful for testing or when config files change.
+ */
+export declare function clearConfigCache(): void;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAY,EAAE,KAAK,WAAW,EAAyB,MAAM,KAAK,CAAC;AAGnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAelD;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,GAAG,SAAS;gBAAxC,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,GAAG,SAAS,EACxD,QAAQ,CAAC,EAAE,MAAM;CAWpB;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,KAAK,CAAC,EAAE,OAAO;gBAD/B,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,OAAO,YAAA;CAKlC;AAqBD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAsC7E;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CA6BzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAWlF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}