@c15t/cli 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/index.mjs

@@ -1,3400 +1,2 @@
 #!/usr/bin/env node
-import * as __rspack_external__clack_prompts_3cae1695 from "@clack/prompts";
-import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-import * as __rspack_external_picocolors from "picocolors";
-import "dotenv/config";
-import * as __rspack_external_open from "open";
-import * as __rspack_external_xstate from "xstate";
-import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
-import * as __rspack_external_node_os_74b4b876 from "node:os";
-import * as __rspack_external_posthog_node_1b07bdf4 from "posthog-node";
-import * as __rspack_external_node_child_process_27f17141 from "node:child_process";
-import * as __rspack_external_node_events_0a6aefe7 from "node:events";
-import * as __rspack_external__c15t_logger_04a510d4 from "@c15t/logger";
-import * as __rspack_external__c15t_backend_db_migrator_ebe6d5c7 from "@c15t/backend/db/migrator";
-import * as __rspack_external__c15t_backend_db_schema_e7c5e6a0 from "@c15t/backend/db/schema";
-import * as __rspack_external_c12 from "c12";
-import * as __rspack_external_figlet from "figlet";
-import * as __rspack_external_fs_extra_ce68a66b from "fs-extra";
-import * as __rspack_external_package_manager_detector_detect_94d6a9ae from "package-manager-detector/detect";
-var __webpack_modules__ = {
-    "./src/constants.ts" (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            $V: ()=>STORAGE_MODES,
-            tl: ()=>URLS
-        });
-        const URLS = {
-            CONSENT_IO: 'https://consent.io',
-            DOCS: 'https://c15t.dev/docs',
-            GITHUB: 'https://github.com/c15t/c15t',
-            DISCORD: 'https://c15t.dev/discord',
-            API_DOCS: 'https://c15t.dev/docs/api',
-            CLI_DOCS: 'https://c15t.dev/docs/cli'
-        };
-        const STORAGE_MODES = {
-            C15T: 'c15t',
-            OFFLINE: 'offline',
-            SELF_HOSTED: 'self-hosted',
-            CUSTOM: 'custom'
-        };
-    },
-    "./src/utils/logger.ts" (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            U0: ()=>validLogLevels,
-            $e: ()=>formatLogMessage,
-            xw: ()=>createCliLogger
-        });
-        var prompts_ = __webpack_require__("@clack/prompts");
-        var external_picocolors_ = __webpack_require__("picocolors");
-        const validLogLevels = [
-            'error',
-            'warn',
-            'info',
-            'debug'
-        ];
-        const formatArgs = (args)=>{
-            if (0 === args.length) return '';
-            return `\n${args.map((arg)=>`  - ${JSON.stringify(arg, null, 2)}`).join('\n')}`;
-        };
-        const formatLogMessage = (logLevel, message, args = [])=>{
-            const messageStr = 'string' == typeof message ? message : String(message);
-            const formattedArgs = formatArgs(args);
-            switch(logLevel){
-                case 'error':
-                    return `${external_picocolors_["default"].bgRed(external_picocolors_["default"].black(' error '))} ${messageStr}${formattedArgs}`;
-                case 'warn':
-                    return `${external_picocolors_["default"].bgYellow(external_picocolors_["default"].black(' warning '))} ${messageStr}${formattedArgs}`;
-                case 'info':
-                    return `${external_picocolors_["default"].bgGreen(external_picocolors_["default"].black(' info '))} ${messageStr}${formattedArgs}`;
-                case 'debug':
-                    return `${external_picocolors_["default"].bgBlack(external_picocolors_["default"].white(' debug '))} ${messageStr}${formattedArgs}`;
-                case 'success':
-                    return `${external_picocolors_["default"].bgGreen(external_picocolors_["default"].white(' success '))} ${messageStr}${formattedArgs}`;
-                case 'failed':
-                    return `${external_picocolors_["default"].bgRed(external_picocolors_["default"].white(' failed '))} ${messageStr}${formattedArgs}`;
-                default:
-                    {
-                        const levelStr = logLevel;
-                        return `[${levelStr.toUpperCase()}] ${messageStr}${formattedArgs}`;
-                    }
-            }
-        };
-        const logMessage = (logLevel, message, ...args)=>{
-            const formattedMessage = formatLogMessage(logLevel, message, args);
-            switch(logLevel){
-                case 'error':
-                    prompts_.log.error(formattedMessage);
-                    break;
-                case 'warn':
-                    prompts_.log.warn(formattedMessage);
-                    break;
-                case 'info':
-                case 'debug':
-                    prompts_.log.info(formattedMessage);
-                    break;
-                case 'success':
-                case 'failed':
-                    prompts_.outro(formattedMessage);
-                    break;
-                default:
-                    prompts_.log.message(formattedMessage);
-            }
-        };
-        const createCliLogger = (level)=>{
-            const baseLogger = (0, __rspack_external__c15t_logger_04a510d4.createLogger)({
-                level,
-                appName: 'c15t',
-                log: (logLevel, message, ...args)=>{
-                    logMessage(logLevel, message, ...args);
-                }
-            });
-            const extendedLogger = baseLogger;
-            extendedLogger.message = (message)=>{
-                prompts_.log.message(message);
-            };
-            extendedLogger.note = (message, ...args)=>{
-                const messageStr = 'string' == typeof message ? message : String(message);
-                const title = args.length > 0 && 'string' == typeof args[0] ? args[0] : void 0;
-                prompts_.note(messageStr, title, {
-                    format: (line)=>line
-                });
-            };
-            extendedLogger.success = (message, ...args)=>{
-                logMessage('success', message, ...args);
-            };
-            extendedLogger.failed = (message, ...args)=>{
-                logMessage('failed', message, ...args);
-                process.exit(0);
-            };
-            extendedLogger.outro = (message)=>{
-                prompts_.outro(message);
-            };
-            return extendedLogger;
-        };
-    },
-    "@clack/prompts" (module) {
-        module.exports = __rspack_external__clack_prompts_3cae1695;
-    },
-    "node:fs/promises" (module) {
-        module.exports = __rspack_external_node_fs_promises_153e37e0;
-    },
-    "node:path" (module) {
-        module.exports = __rspack_external_node_path_c5b9b54f;
-    },
-    picocolors (module) {
-        module.exports = __rspack_external_picocolors;
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-__webpack_require__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.d = (exports, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.f = {};
-    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
-            __webpack_require__.f[key](chunkId, promises);
-            return promises;
-        }, []));
-})();
-(()=>{
-    __webpack_require__.u = (chunkId)=>"" + chunkId + ".mjs";
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    var installedChunks = {
-        410: 0
-    };
-    var installChunk = (data)=>{
-        var __rspack_esm_ids = data.__rspack_esm_ids;
-        var __webpack_modules__ = data.__webpack_modules__;
-        var __rspack_esm_runtime = data.__rspack_esm_runtime;
-        var moduleId, chunkId, i = 0;
-        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
-        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
-        for(; i < __rspack_esm_ids.length; i++){
-            chunkId = __rspack_esm_ids[i];
-            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
-            installedChunks[__rspack_esm_ids[i]] = 0;
-        }
-    };
-    __webpack_require__.f.j = function(chunkId, promises) {
-        var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
-        if (0 !== installedChunkData) if (installedChunkData) promises.push(installedChunkData[1]);
-        else {
-            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e)=>{
-                if (0 !== installedChunks[chunkId]) installedChunks[chunkId] = void 0;
-                throw e;
-            });
-            var promise = Promise.race([
-                promise,
-                new Promise((resolve)=>{
-                    installedChunkData = installedChunks[chunkId] = [
-                        resolve
-                    ];
-                })
-            ]);
-            promises.push(installedChunkData[1] = promise);
-        }
-    };
-})();
-var prompts_ = __webpack_require__("@clack/prompts");
-var external_picocolors_ = __webpack_require__("picocolors");
-function showHelpMenu(context, version, commands, flags) {
-    const { logger } = context;
-    logger.debug('Displaying help menu using command and flag structures.');
-    const commandLines = commands.map((cmd)=>`  ${cmd.name.padEnd(10)} ${cmd.description}`).join('\n');
-    const optionLines = flags.map((flag)=>{
-        const names = flag.names.join(', ');
-        const valuePlaceholder = flag.expectsValue ? ' <value>' : '';
-        return `  ${(names + valuePlaceholder).padEnd(20)} ${flag.description}`;
-    }).join('\n');
-    const helpContent = `c15t CLI version ${version}
-
-Available Commands:
-${commandLines}
-
-Options:
-${optionLines}
-
-Run a command directly (e.g., ${external_picocolors_["default"].cyan('c15t generate')}) or select one interactively when no command is provided.
-
-For more help, visit: https://c15t.dev`;
-    logger.debug('Help menu content generated.');
-    logger.note(helpContent, 'Usage');
-}
-const TELEMETRY_DISABLED_ENV = 'C15T_TELEMETRY_DISABLED';
-const TelemetryEventName = {
-    CLI_INVOKED: 'cli.invoked',
-    CLI_COMPLETED: 'cli.completed',
-    CLI_EXITED: 'cli.exited',
-    CLI_ENVIRONMENT_DETECTED: 'cli.environment_detected',
-    COMMAND_EXECUTED: 'command.executed',
-    COMMAND_SUCCEEDED: 'command.succeeded',
-    COMMAND_FAILED: 'command.failed',
-    COMMAND_UNKNOWN: 'command.unknown',
-    INTERACTIVE_MENU_OPENED: 'ui.menu.opened',
-    INTERACTIVE_MENU_EXITED: 'ui.menu.exited',
-    CONFIG_LOADED: 'config.loaded',
-    CONFIG_ERROR: 'config.error',
-    CONFIG_UPDATED: 'config.updated',
-    HELP_DISPLAYED: 'help.displayed',
-    VERSION_DISPLAYED: 'version.displayed',
-    ONBOARDING_STARTED: 'onboarding.started',
-    ONBOARDING_COMPLETED: 'onboarding.completed',
-    ONBOARDING_EXITED: 'onboarding.exited',
-    ONBOARDING_STORAGE_MODE_SELECTED: 'onboarding.storage_mode_selected',
-    ONBOARDING_C15T_MODE_CONFIGURED: 'onboarding.c15t_mode_configured',
-    ONBOARDING_OFFLINE_MODE_CONFIGURED: 'onboarding.offline_mode_configured',
-    ONBOARDING_SELF_HOSTED_CONFIGURED: 'onboarding.self_hosted_configured',
-    ONBOARDING_CUSTOM_MODE_CONFIGURED: 'onboarding.custom_mode_configured',
-    ONBOARDING_DEPENDENCIES_CHOICE: 'onboarding.dependencies_choice',
-    ONBOARDING_DEPENDENCIES_INSTALLED: 'onboarding.dependencies_installed',
-    ONBOARDING_GITHUB_STAR: 'onboarding.github_star',
-    ERROR_OCCURRED: 'error.occurred',
-    MIGRATION_STARTED: 'migration.started',
-    MIGRATION_PLANNED: 'migration.planned',
-    MIGRATION_EXECUTED: 'migration.executed',
-    MIGRATION_COMPLETED: 'migration.completed',
-    MIGRATION_FAILED: 'migration.failed',
-    GENERATE_STARTED: 'generate.started',
-    GENERATE_COMPLETED: 'generate.completed',
-    GENERATE_FAILED: 'generate.failed',
-    SELF_HOST_STARTED: 'self-host.started',
-    SELF_HOST_COMPLETED: 'self-host.completed',
-    SELF_HOST_FAILED: 'self-host.failed',
-    CLI_STATE_TRANSITION: 'cli.state.transition',
-    CLI_STATE_ERROR: 'cli.state.error',
-    CLI_STATE_CANCELLED: 'cli.state.cancelled',
-    CLI_STATE_COMPLETE: 'cli.state.complete'
-};
-class Telemetry {
-    client = null;
-    disabled;
-    defaultProperties;
-    distinctId;
-    apiKey = 'phc_ViY5LtTmh4kqoumXZB2olPFoTz4AbbDfrogNgFi1MH3';
-    debug;
-    logger;
-    constructor(options){
-        const envDisabled = '1' === process.env[TELEMETRY_DISABLED_ENV] || process.env[TELEMETRY_DISABLED_ENV]?.toLowerCase() === 'true';
-        const hasValidApiKey = !!(this.apiKey && '' !== this.apiKey.trim());
-        this.disabled = options?.disabled ?? envDisabled ?? !hasValidApiKey;
-        this.defaultProperties = options?.defaultProperties ?? {};
-        this.logger = options?.logger;
-        this.debug = options?.debug ?? false;
-        this.distinctId = this.generateAnonymousId();
-        if (this.disabled) {
-            if (!hasValidApiKey) this.logDebug('Telemetry disabled: No API key provided');
-        } else try {
-            this.initClient(options?.client);
-        } catch (error) {
-            this.disabled = true;
-            this.logDebug('Telemetry disabled due to initialization error:', error);
-        }
-    }
-    trackEvent(eventName, properties = {}) {
-        if (this.disabled || !this.client) {
-            if (this.debug) this.logDebug(`Telemetry event skipped (${eventName}): Telemetry disabled or client not initialized`);
-            return;
-        }
-        try {
-            const safeProperties = {};
-            for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
-            if (this.debug) this.logDebug(`Sending telemetry event: ${eventName}`);
-            this.client.capture({
-                distinctId: this.distinctId,
-                event: eventName,
-                properties: {
-                    ...this.defaultProperties,
-                    ...safeProperties,
-                    timestamp: new Date().toISOString()
-                }
-            });
-            this.client.flush();
-        } catch (error) {
-            if (this.debug) this.logDebug(`Error sending telemetry event ${eventName}:`, error);
-        }
-    }
-    trackEventSync(eventName, properties = {}) {
-        if (this.disabled || !this.client) {
-            if (this.debug) this.logDebug('Telemetry disabled or client not initialized');
-            return;
-        }
-        const safeProperties = {};
-        for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
-        if (this.debug) this.logDebug(`Sending telemetry event: ${eventName}`);
-        try {
-            this.client.capture({
-                distinctId: this.distinctId,
-                event: eventName,
-                properties: {
-                    ...this.defaultProperties,
-                    ...safeProperties,
-                    timestamp: new Date().toISOString()
-                }
-            });
-            this.client.flush();
-            if (this.debug) this.logDebug(`Flushed telemetry event: ${eventName}`);
-        } catch (error) {
-            if (this.debug) this.logDebug(`Error sending telemetry: ${error}`);
-        }
-    }
-    trackCommand(command, args = [], flags = {}) {
-        if (this.disabled || !this.client) return;
-        const safeFlags = {};
-        for (const [key, value] of Object.entries(flags))if ('config' !== key && void 0 !== value) safeFlags[key] = value;
-        this.trackEvent(TelemetryEventName.COMMAND_EXECUTED, {
-            command,
-            args: args.join(' '),
-            flagsData: JSON.stringify(safeFlags)
-        });
-    }
-    trackError(error, command) {
-        if (this.disabled || !this.client) return;
-        this.trackEvent(TelemetryEventName.ERROR_OCCURRED, {
-            command,
-            error: error.message,
-            errorName: error.name,
-            stack: 'development' === process.env.NODE_ENV ? error.stack : void 0
-        });
-    }
-    disable() {
-        this.disabled = true;
-    }
-    enable() {
-        this.disabled = false;
-        if (!this.client) this.initClient();
-    }
-    isDisabled() {
-        return this.disabled;
-    }
-    async shutdown() {
-        if (this.client) {
-            await this.client.shutdown();
-            this.client = null;
-        }
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    logDebug(message, ...args) {
-        if (this.logger) this.logger.debug(message, ...args);
-        else console.debug(message, ...args);
-    }
-    initClient(customClient) {
-        if (customClient) {
-            this.client = customClient;
-            if (this.debug) this.logDebug('Using custom PostHog client');
-        } else {
-            if (!this.apiKey || '' === this.apiKey.trim()) {
-                this.disabled = true;
-                this.logDebug('Telemetry disabled: No API key provided');
-                return;
-            }
-            const startTime = Date.now();
-            try {
-                const clientConfig = {
-                    host: 'https://eu.i.posthog.com',
-                    flushInterval: 0,
-                    flushAt: 1,
-                    requestTimeout: 3000
-                };
-                if (this.debug) this.logDebug('Initializing PostHog client with config:', JSON.stringify(clientConfig));
-                this.client = new __rspack_external_posthog_node_1b07bdf4.PostHog(this.apiKey, clientConfig);
-                const initTime = Date.now() - startTime;
-                if (this.debug) this.logDebug('PostHog client initialized in', initTime, 'ms');
-            } catch (error) {
-                this.disabled = true;
-                const errorDetails = error instanceof Error ? {
-                    message: error.message,
-                    name: error.name,
-                    stack: error.stack
-                } : {
-                    rawError: String(error)
-                };
-                if (this.debug) this.logDebug('Telemetry disabled due to initialization error:', JSON.stringify(errorDetails, null, 2));
-                try {
-                    if (this.debug) this.logDebug('Attempting fallback PostHog initialization');
-                    this.client = new __rspack_external_posthog_node_1b07bdf4.PostHog(this.apiKey);
-                    this.disabled = false;
-                    if (this.debug) this.logDebug('PostHog client initialized using fallback method');
-                } catch (fallbackError) {
-                    this.logDebug('Fallback initialization also failed:', fallbackError instanceof Error ? fallbackError.message : String(fallbackError));
-                }
-            }
-        }
-    }
-    generateAnonymousId() {
-        const machineId = __rspack_external_node_crypto_9ba42079["default"].createHash('sha256').update(__rspack_external_node_os_74b4b876["default"].hostname() + __rspack_external_node_os_74b4b876["default"].platform() + __rspack_external_node_os_74b4b876["default"].arch() + __rspack_external_node_os_74b4b876["default"].totalmem()).digest('hex');
-        return machineId;
-    }
-    flushSync() {
-        if (this.disabled || !this.client) return;
-        try {
-            this.client.flush();
-            if (this.debug) this.logDebug('Manually flushed telemetry events');
-        } catch (error) {
-            if (this.debug) this.logDebug(`Error flushing telemetry: ${error}`);
-        }
-    }
-}
-function createTelemetry(options) {
-    return new Telemetry(options);
-}
-var external_node_path_ = __webpack_require__("node:path");
-const DEFAULT_PERSIST_FILENAME = '.c15t-state.json';
-function getPersistPath(projectRoot) {
-    return external_node_path_["default"].join(projectRoot, DEFAULT_PERSIST_FILENAME);
-}
-const NON_SERIALIZABLE_FIELDS = new Set([
-    'cliContext',
-    'spinner',
-    '_parent',
-    '_actorScope',
-    '_processingStatus',
-    '_systemId',
-    'logic',
-    'src',
-    'system',
-    'self',
-    '_snapshot'
-]);
-function makeSerializable(obj, seen = new WeakSet()) {
-    if (null == obj) return obj;
-    if ('object' != typeof obj) return obj;
-    if (seen.has(obj)) return '[Circular]';
-    seen.add(obj);
-    if (Array.isArray(obj)) return obj.map((item)=>makeSerializable(item, seen));
-    if (obj instanceof Date) return obj.toISOString();
-    if (obj instanceof Map) return Object.fromEntries(Array.from(obj.entries()).map(([k, v])=>[
-            k,
-            makeSerializable(v, seen)
-        ]));
-    if (obj instanceof Set) return Array.from(obj).map((v)=>makeSerializable(v, seen));
-    const result = {};
-    for (const [key, value] of Object.entries(obj))if (!NON_SERIALIZABLE_FIELDS.has(key)) {
-        if ('function' != typeof value && 'symbol' != typeof value) result[key] = makeSerializable(value, seen);
-    }
-    return result;
-}
-async function saveSnapshot(snapshot, machineId, persistPath) {
-    const fs = await import("node:fs/promises");
-    const serializableSnapshot = makeSerializable(snapshot);
-    const persisted = {
-        machineId,
-        version: 1,
-        savedAt: Date.now(),
-        snapshot: serializableSnapshot
-    };
-    await fs.writeFile(persistPath, JSON.stringify(persisted, null, 2), 'utf-8');
-}
-async function loadSnapshot(persistPath, machineId) {
-    const fs = await import("node:fs/promises");
-    try {
-        const content = await fs.readFile(persistPath, 'utf-8');
-        const persisted = JSON.parse(content);
-        if (persisted.machineId !== machineId) return null;
-        const maxAge = 86400000;
-        if (Date.now() - persisted.savedAt > maxAge) {
-            await clearSnapshot(persistPath);
-            return null;
-        }
-        return persisted.snapshot;
-    } catch  {
-        return null;
-    }
-}
-async function clearSnapshot(persistPath) {
-    const fs = await import("node:fs/promises");
-    try {
-        await fs.unlink(persistPath);
-    } catch  {}
-}
-async function hasPersistedState(persistPath) {
-    const fs = await import("node:fs/promises");
-    try {
-        await fs.access(persistPath);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function createPersistenceSubscriber(machineId, persistPath, options = {}) {
-    const { persistStates, skipStates = [
-        'exited',
-        'complete',
-        'error'
-    ] } = options;
-    return (snapshot)=>{
-        const stateValue = String(snapshot.value);
-        if (skipStates.includes(stateValue)) return void clearSnapshot(persistPath).catch(()=>{});
-        if (persistStates && !persistStates.includes(stateValue)) return;
-        saveSnapshot(snapshot, machineId, persistPath).catch((error)=>{
-            console.error('Failed to persist state:', error);
-        });
-    };
-}
-function createTelemetrySubscriber(config) {
-    const { telemetry, machineId, skipStates = [] } = config;
-    let lastState = null;
-    let lastStateTime = Date.now();
-    const stateHistory = [];
-    return (snapshot)=>{
-        const currentState = String(snapshot.value);
-        const now = Date.now();
-        if (currentState === lastState) return;
-        if (skipStates.includes(currentState)) return;
-        if (null !== lastState) {
-            const duration = now - lastStateTime;
-            telemetry.trackEvent(TelemetryEventName.CLI_STATE_TRANSITION, {
-                machineId,
-                fromState: lastState,
-                toState: currentState,
-                duration
-            });
-        }
-        stateHistory.push({
-            state: currentState,
-            timestamp: now
-        });
-        if ('error' === currentState || 'preflightError' === currentState) {
-            const ctx = snapshot.context;
-            const errors = ctx?.errors;
-            const lastError = errors?.[errors.length - 1];
-            telemetry.trackEvent(TelemetryEventName.CLI_STATE_ERROR, {
-                machineId,
-                state: currentState,
-                error: lastError?.error?.message ?? 'Unknown error',
-                stateHistory: stateHistory.map((e)=>e.state).join(',')
-            });
-        }
-        if ('exited' === currentState || 'cancelled' === currentState) telemetry.trackEvent(TelemetryEventName.CLI_STATE_CANCELLED, {
-            machineId,
-            lastState: lastState ?? 'unknown',
-            stateHistory: stateHistory.map((e)=>e.state).join(',')
-        });
-        if ('complete' === currentState || 'success' === currentState) {
-            const totalDuration = now - (stateHistory[0]?.timestamp ?? now);
-            telemetry.trackEvent(TelemetryEventName.CLI_STATE_COMPLETE, {
-                machineId,
-                totalDuration,
-                statesVisited: stateHistory.length,
-                stateHistory: stateHistory.map((e)=>e.state).join(',')
-            });
-        }
-        lastState = currentState;
-        lastStateTime = now;
-    };
-}
-function combineSubscribers(...subscribers) {
-    return (snapshot)=>{
-        for (const subscriber of subscribers)try {
-            subscriber(snapshot);
-        } catch (error) {
-            console.error('Subscriber error:', error);
-        }
-    };
-}
-function createDebugSubscriber(machineId, logger) {
-    let lastState = null;
-    return (snapshot)=>{
-        const currentState = String(snapshot.value);
-        if (currentState !== lastState) {
-            const log = logger?.debug ?? console.debug;
-            log(`[${machineId}] State: ${lastState ?? 'initial'} -> ${currentState}`);
-            lastState = currentState;
-        }
-    };
-}
-async function runPackageManagerInstall(projectRoot, dependencies, packageManager) {
-    if (0 === dependencies.length) return;
-    let command;
-    let args;
-    switch(packageManager){
-        case 'npm':
-            command = 'npm';
-            args = [
-                'install',
-                ...dependencies
-            ];
-            break;
-        case 'yarn':
-            command = 'yarn';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        case 'pnpm':
-            command = 'pnpm';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        case 'bun':
-            command = 'bun';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        default:
-            throw new Error(`Unsupported package manager: ${packageManager}`);
-    }
-    const child = (0, __rspack_external_node_child_process_27f17141.spawn)(command, args, {
-        cwd: projectRoot,
-        stdio: 'inherit'
-    });
-    const [exitCode] = await (0, __rspack_external_node_events_0a6aefe7.once)(child, 'exit');
-    if (0 !== exitCode) throw new Error(`Package manager exited with code ${exitCode}`);
-}
-const dependencyInstallActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext, dependencies } = input;
-    const { projectRoot, packageManager, logger } = cliContext;
-    if (0 === dependencies.length) return {
-        success: true,
-        installedDependencies: []
-    };
-    logger.debug(`Installing dependencies: ${dependencies.join(', ')}`);
-    logger.debug(`Using package manager: ${packageManager.name}`);
-    try {
-        await runPackageManagerInstall(projectRoot, dependencies, packageManager.name);
-        return {
-            success: true,
-            installedDependencies: dependencies
-        };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error(`Dependency installation failed: ${errorMessage}`);
-        return {
-            success: false,
-            installedDependencies: [],
-            error: errorMessage
-        };
-    }
-});
-function getManualInstallCommand(dependencies, packageManager) {
-    switch(packageManager){
-        case 'npm':
-            return `npm install ${dependencies.join(' ')}`;
-        case 'yarn':
-            return `yarn add ${dependencies.join(' ')}`;
-        case 'pnpm':
-            return `pnpm add ${dependencies.join(' ')}`;
-        case 'bun':
-            return `bun add ${dependencies.join(' ')}`;
-        default:
-            return `npm install ${dependencies.join(' ')}`;
-    }
-}
-const checkDependenciesActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { projectRoot, dependencies } = input;
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const installed = [];
-    const missing = [];
-    try {
-        const packageJsonPath = path.join(projectRoot, 'package.json');
-        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-        const allDeps = {
-            ...packageJson.dependencies,
-            ...packageJson.devDependencies
-        };
-        for (const dep of dependencies){
-            const depName = dep.startsWith('@') ? dep : dep.split('@')[0];
-            if (depName && depName in allDeps) installed.push(dep);
-            else missing.push(dep);
-        }
-    } catch  {
-        missing.push(...dependencies);
-    }
-    return {
-        installed,
-        missing
-    };
-});
-async function readFileForBackup(filePath) {
-    const fs = await import("node:fs/promises");
-    try {
-        return await fs.readFile(filePath, 'utf-8');
-    } catch  {
-        return null;
-    }
-}
-async function fileExists(filePath) {
-    const fs = await import("node:fs/promises");
-    try {
-        await fs.access(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function formatGeneratedFiles(projectRoot, files, logger) {
-    const fs = await import("node:fs/promises");
-    const { execFile } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const execFileAsync = promisify(execFile);
-    const codeFiles = files.filter((f)=>f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx'));
-    if (0 === codeFiles.length) return;
-    const formatters = [
-        {
-            bin: external_node_path_["default"].join(projectRoot, 'node_modules', '.bin', 'prettier'),
-            args: [
-                '--write'
-            ]
-        },
-        {
-            bin: external_node_path_["default"].join(projectRoot, 'node_modules', '.bin', 'biome'),
-            args: [
-                'format',
-                '--write'
-            ]
-        }
-    ];
-    for (const { bin, args } of formatters)try {
-        await fs.access(bin);
-        await execFileAsync(bin, [
-            ...args,
-            ...codeFiles
-        ], {
-            cwd: projectRoot
-        });
-        logger.debug(`Formatted ${codeFiles.length} files with ${external_node_path_["default"].basename(bin)}`);
-        return;
-    } catch  {}
-    logger.debug('No formatter found, skipping formatting');
-}
-const fileGenerationActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext, mode, backendURL, useEnvFile, proxyNextjs, enableSSR, enableDevTools, uiStyle, expandedTheme, selectedScripts } = input;
-    const filesCreated = [];
-    const filesModified = [];
-    const result = {
-        filesCreated: [],
-        filesModified: [],
-        configPath: null,
-        layoutPath: null,
-        nextConfigPath: null,
-        envPath: null
-    };
-    const { projectRoot, framework, cwd, logger } = cliContext;
-    framework.pkg;
-    const { generateFiles } = await __webpack_require__.e("760").then(__webpack_require__.bind(__webpack_require__, "./src/commands/generate/options/utils/generate-files.ts"));
-    const spinnerMock = {
-        start: (msg)=>logger.debug(`[spinner] ${msg}`),
-        stop: (msg)=>logger.debug(`[spinner] ${msg}`),
-        message: (msg)=>logger.debug(`[spinner] ${msg}`)
-    };
-    try {
-        const potentialFiles = [
-            external_node_path_["default"].join(projectRoot, 'c15t.config.ts'),
-            external_node_path_["default"].join(projectRoot, '.env.local'),
-            external_node_path_["default"].join(projectRoot, '.env.example'),
-            external_node_path_["default"].join(projectRoot, 'next.config.ts'),
-            external_node_path_["default"].join(projectRoot, 'next.config.js'),
-            external_node_path_["default"].join(projectRoot, 'next.config.mjs')
-        ];
-        for (const filePath of potentialFiles){
-            const exists = await fileExists(filePath);
-            if (exists) {
-                const backup = await readFileForBackup(filePath);
-                if (null !== backup) filesModified.push({
-                    path: filePath,
-                    backup,
-                    type: 'modified'
-                });
-            }
-        }
-        const generateResult = await generateFiles({
-            context: cliContext,
-            mode: mode,
-            spinner: spinnerMock,
-            backendURL: backendURL ?? void 0,
-            useEnvFile,
-            proxyNextjs,
-            enableSSR,
-            enableDevTools,
-            uiStyle,
-            expandedTheme: expandedTheme ?? void 0,
-            selectedScripts
-        });
-        if (generateResult.configPath) {
-            result.configPath = generateResult.configPath;
-            if (!filesModified.some((f)=>f.path === generateResult.configPath)) filesCreated.push(generateResult.configPath);
-        }
-        if (generateResult.layoutPath) result.layoutPath = generateResult.layoutPath;
-        if (generateResult.nextConfigPath) {
-            result.nextConfigPath = generateResult.nextConfigPath;
-            if (generateResult.nextConfigCreated) filesCreated.push(generateResult.nextConfigPath);
-        }
-        if (useEnvFile && backendURL) {
-            const envPath = external_node_path_["default"].join(projectRoot, '.env.local');
-            const envExamplePath = external_node_path_["default"].join(projectRoot, '.env.example');
-            if (!filesModified.some((f)=>f.path === envPath) && await fileExists(envPath)) filesCreated.push(envPath);
-            result.envPath = envPath;
-            if (!filesModified.some((f)=>f.path === envExamplePath) && await fileExists(envExamplePath)) filesCreated.push(envExamplePath);
-        }
-        result.filesCreated = filesCreated;
-        result.filesModified = filesModified;
-        const allFiles = [
-            ...filesCreated,
-            ...filesModified.map((f)=>f.path),
-            generateResult.layoutPath
-        ].filter((f)=>!!f);
-        await formatGeneratedFiles(projectRoot, allFiles, logger);
-        return result;
-    } catch (error) {
-        result.filesCreated = filesCreated;
-        result.filesModified = filesModified;
-        throw error;
-    }
-});
-const rollbackActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { filesCreated, filesModified } = input;
-    const fs = await import("node:fs/promises");
-    const errors = [];
-    for (const filePath of filesCreated)try {
-        await fs.unlink(filePath);
-    } catch (error) {
-        errors.push(`Failed to delete ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    for (const mod of filesModified)try {
-        await fs.writeFile(mod.path, mod.backup, 'utf-8');
-    } catch (error) {
-        errors.push(`Failed to restore ${mod.path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return {
-        success: 0 === errors.length,
-        errors
-    };
-});
-async function preflight_fileExists(filePath) {
-    try {
-        const fs = await import("node:fs/promises");
-        await fs.access(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function checkGitStatus(projectRoot) {
-    try {
-        const gitDir = external_node_path_["default"].join(projectRoot, '.git');
-        const isGitRepo = await preflight_fileExists(gitDir);
-        if (!isGitRepo) return {
-            name: 'Git',
-            status: 'warn',
-            message: 'Not a git repository',
-            hint: 'Consider initializing git to track changes'
-        };
-        return {
-            name: 'Git',
-            status: 'pass',
-            message: 'Git repository detected'
-        };
-    } catch  {
-        return {
-            name: 'Git',
-            status: 'warn',
-            message: 'Could not check git status'
-        };
-    }
-}
-async function runPreflightChecks(context) {
-    const { projectRoot, framework, packageManager, logger } = context;
-    const checks = [];
-    logger.debug('Running preflight checks...');
-    const packageJsonPath = external_node_path_["default"].join(projectRoot, 'package.json');
-    const hasPackageJson = await preflight_fileExists(packageJsonPath);
-    checks.push({
-        name: 'package.json',
-        status: hasPackageJson ? 'pass' : 'fail',
-        message: hasPackageJson ? 'Found package.json' : 'No package.json found',
-        hint: hasPackageJson ? void 0 : 'Make sure you are in a JavaScript/TypeScript project'
-    });
-    checks.push({
-        name: 'Framework',
-        status: framework.framework ? 'pass' : 'warn',
-        message: framework.framework ? `Detected ${framework.framework}` : 'No framework detected',
-        hint: framework.framework ? void 0 : 'Will use vanilla JavaScript setup'
-    });
-    if ('c15t' !== framework.pkg) checks.push({
-        name: 'React',
-        status: framework.hasReact ? 'pass' : 'warn',
-        message: framework.hasReact ? `Found React ${framework.reactVersion || ''}` : 'React not detected',
-        hint: framework.hasReact ? void 0 : 'c15t works best with React'
-    });
-    checks.push({
-        name: 'Package Manager',
-        status: packageManager.name ? 'pass' : 'warn',
-        message: packageManager.name ? `Using ${packageManager.name}` : 'No package manager detected',
-        hint: packageManager.name ? void 0 : 'Will default to npm'
-    });
-    const gitCheck = await checkGitStatus(projectRoot);
-    checks.push(gitCheck);
-    const configPath = external_node_path_["default"].join(projectRoot, 'c15t.config.ts');
-    const hasExistingConfig = await preflight_fileExists(configPath);
-    checks.push({
-        name: 'Existing config',
-        status: hasExistingConfig ? 'warn' : 'pass',
-        message: hasExistingConfig ? 'c15t.config.ts already exists' : 'No existing configuration',
-        hint: hasExistingConfig ? 'Existing config will be overwritten' : void 0
-    });
-    const hasFailures = checks.some((c)=>'fail' === c.status);
-    return {
-        passed: !hasFailures,
-        checks,
-        projectRoot,
-        framework: {
-            name: framework.framework,
-            version: framework.frameworkVersion,
-            pkg: framework.pkg,
-            hasReact: framework.hasReact,
-            reactVersion: framework.reactVersion,
-            tailwindVersion: framework.tailwindVersion
-        },
-        packageManager
-    };
-}
-const preflightActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    if (!cliContext) throw new Error('CLI context is required for preflight checks');
-    return runPreflightChecks(cliContext);
-});
-function getStatusIcon(status) {
-    switch(status){
-        case 'pass':
-            return external_picocolors_["default"].green('✓');
-        case 'warn':
-            return external_picocolors_["default"].yellow('⚠');
-        case 'fail':
-            return external_picocolors_["default"].red('✗');
-        default:
-            return ' ';
-    }
-}
-function displayPreflightResults(context, checks) {
-    const { logger } = context;
-    const lines = [];
-    lines.push('');
-    lines.push(external_picocolors_["default"].bold('Pre-flight checks:'));
-    for (const check of checks){
-        const icon = getStatusIcon(check.status);
-        lines.push(`  ${icon} ${check.message}`);
-        if (check.hint && 'pass' !== check.status) lines.push(`    ${external_picocolors_["default"].dim(check.hint)}`);
-    }
-    lines.push('');
-    logger.message(lines.join('\n'));
-}
-function displayPreflightFailure(context, checks) {
-    const { logger } = context;
-    const lines = [];
-    lines.push(external_picocolors_["default"].red('Pre-flight checks failed'));
-    lines.push('');
-    const failures = checks.filter((c)=>'fail' === c.status);
-    for (const check of failures){
-        lines.push(`  ${external_picocolors_["default"].red('•')} ${check.message}`);
-        if (check.hint) lines.push(`    ${check.hint}`);
-    }
-    lines.push('');
-    lines.push('Please fix the issues above and try again.');
-    logger.message(lines.join('\n'));
-}
-async function getDevToolsOption({ context, handleCancel, onCancel }) {
-    const isReactProject = '@c15t/react' === context.framework.pkg || '@c15t/nextjs' === context.framework.pkg;
-    context.logger.info("c15t DevTools helps you inspect consent state, scripts, and location overrides during development.");
-    context.logger.info('Learn more: https://c15t.com/docs/dev-tools/overview');
-    const enableDevTools = await prompts_.select({
-        message: 'Install and enable c15t DevTools?',
-        options: [
-            {
-                value: true,
-                label: 'Yes (Recommended)',
-                hint: isReactProject ? 'Adds <C15TDevTools /> to generated consent components' : 'Adds createDevTools() setup to c15t.config.ts'
-            },
-            {
-                value: false,
-                label: 'No',
-                hint: 'Skip DevTools installation and setup'
-            }
-        ],
-        initialValue: true
-    });
-    const cancelled = handleCancel?.(enableDevTools) ?? prompts_.isCancel(enableDevTools);
-    if (cancelled) {
-        if (onCancel) onCancel();
-        context.error.handleCancel('Setup cancelled.', {
-            command: 'onboarding',
-            stage: 'dev_tools_option'
-        });
-    }
-    return enableDevTools;
-}
-async function getSSROption({ context, handleCancel, onCancel }) {
-    context.logger.info('SSR consent prefetch starts data loading on the server for faster banner visibility.');
-    context.logger.info('Tradeoff: this uses Next.js headers() and makes the route dynamic (not fully static).');
-    context.logger.info('On slow backends or cross-region setups, SSR can increase TTFB. Measure both TTFB and banner visibility.');
-    context.logger.info('Learn more: https://c15t.com/docs/frameworks/nextjs/ssr');
-    const enableSSR = await prompts_.select({
-        message: 'Enable SSR consent prefetch? (faster first banner visibility, dynamic route)',
-        options: [
-            {
-                value: true,
-                label: 'Yes (Recommended)',
-                hint: 'Fetch consent data on server and stream to client'
-            },
-            {
-                value: false,
-                label: 'No',
-                hint: 'Client-only fetch after hydration (better for fully static pages)'
-            }
-        ],
-        initialValue: true
-    });
-    const cancelled = handleCancel?.(enableSSR) ?? prompts_.isCancel(enableSSR);
-    if (cancelled) {
-        if (onCancel) onCancel();
-        context.error.handleCancel('Setup cancelled.', {
-            command: 'onboarding',
-            stage: 'ssr_option'
-        });
-    }
-    return enableSSR;
-}
-function isCancel(value) {
-    return prompts_.isCancel(value);
-}
-class PromptCancelledError extends Error {
-    constructor(stage){
-        super(`Prompt cancelled at stage: ${stage}`);
-        this.name = 'PromptCancelledError';
-    }
-}
-const modeSelectionActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const result = await prompts_.select({
-        message: 'How would you like to store consent decisions?',
-        initialValue: input.initialMode ?? 'c15t',
-        options: [
-            {
-                value: 'c15t',
-                label: 'Hosted c15t (consent.io)',
-                hint: 'Recommended: Fully managed service'
-            },
-            {
-                value: 'offline',
-                label: 'Offline Mode',
-                hint: 'Store in browser, no backend needed'
-            },
-            {
-                value: 'self-hosted',
-                label: 'Self-Hosted',
-                hint: 'Run your own c15t backend'
-            },
-            {
-                value: 'custom',
-                label: 'Custom Implementation',
-                hint: 'Full control over storage logic'
-            }
-        ]
-    });
-    if (isCancel(result)) throw new PromptCancelledError('mode_selection');
-    return {
-        mode: result
-    };
-});
-const accountCreationActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    const needsAccount = await prompts_.confirm({
-        message: 'Do you need to create a consent.io account?',
-        initialValue: true
-    });
-    if (isCancel(needsAccount)) throw new PromptCancelledError('account_creation');
-    if (!needsAccount) return {
-        needsAccount: false,
-        browserOpened: false
-    };
-    prompts_.note(`We'll open your browser to create a consent.io account and set up your instance.\nFollow these steps:\n1. Sign up for a consent.io account\n2. Create a new instance in the dashboard\n3. Configure your trusted origins (domains that can connect)\n4. Copy the provided backendURL (e.g., https://your-instance.c15t.dev)`, 'consent.io Setup');
-    const shouldOpen = await prompts_.confirm({
-        message: 'Open browser to sign up for consent.io?',
-        initialValue: true
-    });
-    if (isCancel(shouldOpen)) throw new PromptCancelledError('browser_open');
-    let browserOpened = false;
-    if (shouldOpen) try {
-        const open = (await import("open")).default;
-        await open('https://consent.io/dashboard/register?ref=cli');
-        browserOpened = true;
-        const enterPressed = await prompts_.text({
-            message: 'Press Enter once you have created your instance and have the backendURL'
-        });
-        if (isCancel(enterPressed)) throw new PromptCancelledError('url_input_wait');
-    } catch (error) {
-        if (error instanceof PromptCancelledError) throw error;
-        cliContext.logger.warn('Failed to open browser automatically. Please visit https://consent.io/dashboard/register manually.');
-    }
-    return {
-        needsAccount: true,
-        browserOpened
-    };
-});
-const backendURLActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { initialURL, isC15tMode } = input;
-    const placeholder = isC15tMode ? 'https://your-instance.c15t.dev' : 'https://your-backend.example.com/api/c15t';
-    const result = await prompts_.text({
-        message: isC15tMode ? 'Enter your consent.io instance URL:' : 'Enter your self-hosted backend URL:',
-        placeholder,
-        initialValue: initialURL,
-        validate: (value)=>{
-            if (!value || '' === value) return 'URL is required';
-            try {
-                const url = new URL(value);
-                if (isC15tMode && !url.hostname.endsWith('.c15t.dev')) return 'Please enter a valid *.c15t.dev URL';
-            } catch  {
-                return 'Please enter a valid URL';
-            }
-        }
-    });
-    if (isCancel(result)) throw new PromptCancelledError('backend_url');
-    return {
-        url: result
-    };
-});
-const backendOptionsActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    const useEnvFile = await prompts_.confirm({
-        message: 'Store the backendURL in a .env file? (Recommended, URL is public)',
-        initialValue: true
-    });
-    if (isCancel(useEnvFile)) throw new PromptCancelledError('env_file');
-    let proxyNextjs = false;
-    if ('@c15t/nextjs' === cliContext.framework.pkg) {
-        cliContext.logger.info('Learn more about Next.js Rewrites: https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites');
-        const proxyResult = await prompts_.confirm({
-            message: 'Proxy requests to your instance with Next.js Rewrites? (Recommended)',
-            initialValue: true
-        });
-        if (isCancel(proxyResult)) throw new PromptCancelledError('proxy_nextjs');
-        proxyNextjs = proxyResult;
-    }
-    return {
-        useEnvFile: useEnvFile,
-        proxyNextjs
-    };
-});
-const frontendOptionsActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext, hasBackend } = input;
-    const pkg = cliContext.framework.pkg;
-    let enableSSR;
-    let enableDevTools = false;
-    let uiStyle = 'prebuilt';
-    let expandedTheme;
-    if ('@c15t/nextjs' === pkg) {
-        if (hasBackend) {
-            const { existsSync } = await import("node:fs");
-            const { join } = await import("node:path");
-            const projectRoot = cliContext.projectRoot;
-            const isAppRouter = [
-                'app/layout.tsx',
-                'src/app/layout.tsx',
-                'app/layout.ts',
-                'src/app/layout.ts'
-            ].some((p)=>existsSync(join(projectRoot, p)));
-            if (isAppRouter) enableSSR = await getSSROption({
-                context: cliContext,
-                onCancel: ()=>{
-                    throw new PromptCancelledError('ssr_option');
-                }
-            });
-        }
-        cliContext.logger.info('Choose how you want your consent UI components generated.');
-        cliContext.logger.info('Learn more: https://c15t.com/docs/frameworks/nextjs/customization');
-        const styleResult = await prompts_.select({
-            message: 'UI component style:',
-            options: [
-                {
-                    value: 'prebuilt',
-                    label: 'Prebuilt (Recommended)',
-                    hint: 'Ready-to-use components'
-                },
-                {
-                    value: 'expanded',
-                    label: 'Compound components',
-                    hint: 'Full customization control'
-                }
-            ],
-            initialValue: 'prebuilt'
-        });
-        if (isCancel(styleResult)) throw new PromptCancelledError('ui_style');
-        uiStyle = styleResult;
-        const themeResult = await prompts_.select({
-            message: 'Theme preset:',
-            options: [
-                {
-                    value: 'none',
-                    label: 'None',
-                    hint: 'No preset styling'
-                },
-                {
-                    value: 'minimal',
-                    label: 'Minimal',
-                    hint: 'Clean light theme'
-                },
-                {
-                    value: 'dark',
-                    label: 'Dark',
-                    hint: 'High contrast dark mode'
-                },
-                {
-                    value: 'tailwind',
-                    label: 'Tailwind',
-                    hint: 'Uses Tailwind utility classes'
-                }
-            ],
-            initialValue: 'none'
-        });
-        if (isCancel(themeResult)) throw new PromptCancelledError('expanded_theme');
-        expandedTheme = themeResult;
-    }
-    if ('@c15t/react' === pkg) {
-        cliContext.logger.info('Choose how you want your consent UI components generated.');
-        const styleResult = await prompts_.select({
-            message: 'UI component style:',
-            options: [
-                {
-                    value: 'prebuilt',
-                    label: 'Prebuilt (Recommended)',
-                    hint: 'Ready-to-use components'
-                },
-                {
-                    value: 'expanded',
-                    label: 'Compound components',
-                    hint: 'Full customization control'
-                }
-            ],
-            initialValue: 'prebuilt'
-        });
-        if (isCancel(styleResult)) throw new PromptCancelledError('ui_style');
-        uiStyle = styleResult;
-        const reactThemeResult = await prompts_.select({
-            message: 'Theme preset:',
-            options: [
-                {
-                    value: 'none',
-                    label: 'None',
-                    hint: 'No preset styling'
-                },
-                {
-                    value: 'minimal',
-                    label: 'Minimal',
-                    hint: 'Clean light theme'
-                },
-                {
-                    value: 'dark',
-                    label: 'Dark',
-                    hint: 'High contrast dark mode'
-                },
-                {
-                    value: 'tailwind',
-                    label: 'Tailwind',
-                    hint: 'Uses Tailwind utility classes'
-                }
-            ],
-            initialValue: 'none'
-        });
-        if (isCancel(reactThemeResult)) throw new PromptCancelledError('expanded_theme');
-        expandedTheme = reactThemeResult;
-    }
-    if ('c15t' === pkg || '@c15t/react' === pkg || '@c15t/nextjs' === pkg) enableDevTools = await getDevToolsOption({
-        context: cliContext,
-        onCancel: ()=>{
-            throw new PromptCancelledError('dev_tools_option');
-        }
-    });
-    return {
-        enableSSR,
-        enableDevTools,
-        uiStyle,
-        expandedTheme
-    };
-});
-const AVAILABLE_SCRIPTS = [
-    {
-        value: 'google-tag-manager',
-        label: 'Google Tag Manager',
-        hint: "GTM container script"
-    },
-    {
-        value: 'google-tag',
-        label: 'Google Tag (gtag.js)',
-        hint: 'Google Analytics 4'
-    },
-    {
-        value: 'meta-pixel',
-        label: 'Meta Pixel',
-        hint: 'Facebook/Instagram tracking'
-    },
-    {
-        value: 'posthog',
-        label: 'PostHog',
-        hint: 'Product analytics'
-    },
-    {
-        value: 'linkedin-insights',
-        label: 'LinkedIn Insight Tag',
-        hint: 'LinkedIn conversion tracking'
-    },
-    {
-        value: 'tiktok-pixel',
-        label: 'TikTok Pixel',
-        hint: 'TikTok ads tracking'
-    },
-    {
-        value: 'x-pixel',
-        label: 'X (Twitter) Pixel',
-        hint: 'X/Twitter conversion tracking'
-    },
-    {
-        value: 'microsoft-uet',
-        label: 'Microsoft UET',
-        hint: 'Bing Ads tracking'
-    },
-    {
-        value: 'databuddy',
-        label: 'Databuddy',
-        hint: 'Data collection'
-    }
-];
-const scriptsOptionActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    cliContext.logger.info("The @c15t/scripts package provides pre-configured third-party scripts with consent management.");
-    const addScripts = await prompts_.confirm({
-        message: "Add @c15t/scripts for third-party script management?",
-        initialValue: true
-    });
-    if (isCancel(addScripts)) throw new PromptCancelledError("scripts_option");
-    if (!addScripts) return {
-        addScripts: false,
-        selectedScripts: []
-    };
-    const selected = await prompts_.multiselect({
-        message: "Which scripts do you want to add?",
-        options: AVAILABLE_SCRIPTS.map((s)=>({
-                value: s.value,
-                label: s.label,
-                hint: s.hint
-            })),
-        required: false
-    });
-    if (isCancel(selected)) throw new PromptCancelledError("scripts_selection");
-    return {
-        addScripts: true,
-        selectedScripts: selected
-    };
-});
-const installConfirmActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { dependencies, packageManager } = input;
-    const depList = dependencies.join(', ');
-    const result = await prompts_.confirm({
-        message: `Install dependencies (${depList}) with ${packageManager}?`,
-        initialValue: true
-    });
-    if (isCancel(result)) throw new PromptCancelledError('install_confirm');
-    return {
-        confirmed: result
-    };
-});
-const githubStarActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    const result = await prompts_.confirm({
-        message: 'Would you like to star c15t on GitHub now?',
-        initialValue: true
-    });
-    if (isCancel(result)) return {
-        opened: false
-    };
-    if (result) try {
-        const open = (await import("open")).default;
-        await open('https://github.com/c15t/c15t');
-        cliContext.logger.success('GitHub repository opened. Thank you for your support!');
-        return {
-            opened: true
-        };
-    } catch  {
-        cliContext.logger.info('You can star us later by visiting: https://github.com/c15t/c15t');
-    }
-    return {
-        opened: false
-    };
-});
-function preflightPassed({ context }) {
-    return context.preflightPassed;
-}
-function preflightFailed({ context }) {
-    return !context.preflightPassed;
-}
-function hasModeArg({ context }) {
-    return null !== context.modeArg;
-}
-function guards_isC15tMode({ context }) {
-    return 'c15t' === context.selectedMode;
-}
-function isOfflineMode({ context }) {
-    return 'offline' === context.selectedMode;
-}
-function isSelfHostedMode({ context }) {
-    return 'self-hosted' === context.selectedMode;
-}
-function isCustomMode({ context }) {
-    return 'custom' === context.selectedMode;
-}
-function modeRequiresBackend({ context }) {
-    return 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode;
-}
-function modeNoBackend({ context }) {
-    return 'offline' === context.selectedMode || 'custom' === context.selectedMode;
-}
-function isNextjs({ context }) {
-    return context.framework?.pkg === '@c15t/nextjs';
-}
-function isReact({ context }) {
-    return context.framework?.pkg === '@c15t/react';
-}
-function isCore({ context }) {
-    return context.framework?.pkg === 'c15t';
-}
-function guards_hasReact({ context }) {
-    return context.framework?.hasReact ?? false;
-}
-function hasTailwind({ context }) {
-    return context.framework?.tailwindVersion !== null;
-}
-function hasBackendURL({ context }) {
-    return null !== context.backendURL && '' !== context.backendURL;
-}
-function isExpandedUIStyle({ context }) {
-    return 'expanded' === context.uiStyle;
-}
-function installConfirmed({ context }) {
-    return context.installConfirmed;
-}
-function installSucceeded({ context }) {
-    return context.installSucceeded;
-}
-function hasFilesToRollback({ context }) {
-    return context.filesCreated.length > 0 || context.filesModified.length > 0;
-}
-function hasDependencies({ context }) {
-    return context.dependenciesToAdd.length > 0;
-}
-function hasErrors({ context }) {
-    return context.errors.length > 0;
-}
-function needsCleanup({ context }) {
-    return !context.cleanupDone && (context.filesCreated.length > 0 || context.filesModified.length > 0);
-}
-function shouldPromptSSR({ context }) {
-    return context.framework?.pkg === '@c15t/nextjs' && ('c15t' === context.selectedMode || 'self-hosted' === context.selectedMode);
-}
-function shouldPromptUIStyle({ context }) {
-    return context.framework?.pkg === '@c15t/nextjs' || context.framework?.pkg === '@c15t/react';
-}
-const guards = {
-    preflightPassed,
-    preflightFailed,
-    hasModeArg,
-    isC15tMode: guards_isC15tMode,
-    isOfflineMode,
-    isSelfHostedMode,
-    isCustomMode,
-    modeRequiresBackend,
-    modeNoBackend,
-    isNextjs,
-    isReact,
-    isCore,
-    hasReact: guards_hasReact,
-    hasTailwind,
-    hasBackendURL,
-    isExpandedUIStyle,
-    installConfirmed,
-    installSucceeded,
-    hasFilesToRollback,
-    hasDependencies,
-    hasErrors,
-    needsCleanup,
-    shouldPromptSSR,
-    shouldPromptUIStyle
-};
-function createInitialContext(cliContext, modeArg) {
-    return {
-        cliContext: cliContext ?? null,
-        projectRoot: cliContext?.projectRoot ?? '',
-        framework: null,
-        packageManager: null,
-        preflightPassed: false,
-        preflightChecks: [],
-        selectedMode: null,
-        modeArg: modeArg ?? null,
-        backendURL: null,
-        useEnvFile: true,
-        proxyNextjs: true,
-        enableSSR: false,
-        enableDevTools: false,
-        uiStyle: 'prebuilt',
-        expandedTheme: null,
-        addScripts: false,
-        selectedScripts: [],
-        filesCreated: [],
-        filesModified: [],
-        dependenciesToAdd: [],
-        installConfirmed: false,
-        installAttempted: false,
-        installSucceeded: false,
-        runMigrations: false,
-        cancelReason: null,
-        cleanupDone: false,
-        errors: [],
-        stateHistory: []
-    };
-}
-const generateMachine = (0, __rspack_external_xstate.setup)({
-    types: {
-        context: {},
-        events: {},
-        input: {}
-    },
-    guards: guards,
-    actors: {
-        preflight: preflightActor,
-        modeSelection: modeSelectionActor,
-        accountCreation: accountCreationActor,
-        backendURL: backendURLActor,
-        backendOptions: backendOptionsActor,
-        frontendOptions: frontendOptionsActor,
-        scriptsOption: scriptsOptionActor,
-        fileGeneration: fileGenerationActor,
-        checkDependencies: checkDependenciesActor,
-        installConfirm: installConfirmActor,
-        dependencyInstall: dependencyInstallActor,
-        rollback: rollbackActor,
-        githubStar: githubStarActor
-    }
-}).createMachine({
-    id: 'generate',
-    initial: 'idle',
-    context: ({ input })=>createInitialContext(input.cliContext, input.modeArg),
-    on: {
-        CANCEL: {
-            target: '.cancelling',
-            actions: (0, __rspack_external_xstate.assign)({
-                cancelReason: ({ event })=>event.reason ?? 'User cancelled'
-            })
-        }
-    },
-    states: {
-        idle: {
-            on: {
-                START: 'preflight'
-            }
-        },
-        preflight: {
-            invoke: {
-                src: 'preflight',
-                input: ({ context })=>({
-                        cliContext: context.cliContext
-                    }),
-                onDone: [
-                    {
-                        guard: ({ event })=>event.output.passed,
-                        target: 'modeSelection',
-                        actions: [
-                            (0, __rspack_external_xstate.assign)({
-                                preflightPassed: ({ event })=>event.output.passed,
-                                preflightChecks: ({ event })=>event.output.checks,
-                                projectRoot: ({ event })=>event.output.projectRoot,
-                                framework: ({ event })=>event.output.framework,
-                                packageManager: ({ event })=>event.output.packageManager
-                            }),
-                            ({ context, event })=>{
-                                if (context.cliContext) displayPreflightResults(context.cliContext, event.output.checks);
-                            }
-                        ]
-                    },
-                    {
-                        target: 'preflightError',
-                        actions: (0, __rspack_external_xstate.assign)({
-                            preflightPassed: false,
-                            preflightChecks: ({ event })=>event.output.checks
-                        })
-                    }
-                ],
-                onError: {
-                    target: 'error',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        errors: ({ context, event })=>[
-                                ...context.errors,
-                                {
-                                    state: 'preflight',
-                                    error: event.error,
-                                    timestamp: Date.now()
-                                }
-                            ]
-                    })
-                }
-            }
-        },
-        preflightError: {
-            entry: ({ context })=>{
-                if (context.cliContext) displayPreflightFailure(context.cliContext, context.preflightChecks);
-            },
-            on: {
-                RETRY: {
-                    target: 'preflight',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        preflightPassed: false,
-                        preflightChecks: [],
-                        errors: []
-                    })
-                }
-            },
-            after: {
-                100: 'exited'
-            }
-        },
-        modeSelection: {
-            always: [
-                {
-                    guard: 'hasModeArg',
-                    target: 'routeToMode',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        selectedMode: ({ context })=>context.modeArg
-                    })
-                }
-            ],
-            invoke: {
-                src: 'modeSelection',
-                input: ()=>({}),
-                onDone: {
-                    target: 'routeToMode',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        selectedMode: ({ event })=>event.output.mode
-                    })
-                },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Mode selection cancelled'
-                    })
-                }
-            }
-        },
-        routeToMode: {
-            always: [
-                {
-                    guard: 'isC15tMode',
-                    target: 'c15tMode'
-                },
-                {
-                    guard: 'isOfflineMode',
-                    target: 'offlineMode'
-                },
-                {
-                    guard: 'isSelfHostedMode',
-                    target: 'selfHostedMode'
-                },
-                {
-                    guard: 'isCustomMode',
-                    target: 'customMode'
-                },
-                {
-                    target: 'customMode'
-                }
-            ]
-        },
-        c15tMode: {
-            initial: 'accountCreation',
-            states: {
-                accountCreation: {
-                    invoke: {
-                        src: 'accountCreation',
-                        input: ({ context })=>({
-                                cliContext: context.cliContext
-                            }),
-                        onDone: 'backendURL',
-                        onError: {
-                            target: '#generate.cancelling',
-                            actions: (0, __rspack_external_xstate.assign)({
-                                cancelReason: 'Account creation cancelled'
-                            })
-                        }
-                    }
-                },
-                backendURL: {
-                    invoke: {
-                        src: 'backendURL',
-                        input: ()=>({
-                                isC15tMode: true
-                            }),
-                        onDone: {
-                            target: '#generate.backendOptions',
-                            actions: (0, __rspack_external_xstate.assign)({
-                                backendURL: ({ event })=>event.output.url
-                            })
-                        },
-                        onError: {
-                            target: '#generate.cancelling',
-                            actions: (0, __rspack_external_xstate.assign)({
-                                cancelReason: 'Backend URL entry cancelled'
-                            })
-                        }
-                    }
-                }
-            }
-        },
-        offlineMode: {
-            always: 'frontendOptions'
-        },
-        selfHostedMode: {
-            invoke: {
-                src: 'backendURL',
-                input: ()=>({
-                        isC15tMode: false
-                    }),
-                onDone: {
-                    target: 'backendOptions',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        backendURL: ({ event })=>event.output.url
-                    })
-                },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Backend URL entry cancelled'
-                    })
-                }
-            }
-        },
-        customMode: {
-            always: 'frontendOptions'
-        },
-        backendOptions: {
-            invoke: {
-                src: 'backendOptions',
-                input: ({ context })=>({
-                        cliContext: context.cliContext,
-                        backendURL: context.backendURL
-                    }),
-                onDone: {
-                    target: 'frontendOptions',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        useEnvFile: ({ event })=>event.output.useEnvFile,
-                        proxyNextjs: ({ event })=>event.output.proxyNextjs
-                    })
-                },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Backend options cancelled'
-                    })
-                }
-            }
-        },
-        frontendOptions: {
-            invoke: {
-                src: 'frontendOptions',
-                input: ({ context })=>({
-                        cliContext: context.cliContext,
-                        hasBackend: 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode
-                    }),
-                onDone: {
-                    target: "scriptsOptions",
-                    actions: (0, __rspack_external_xstate.assign)({
-                        enableSSR: ({ event, context })=>event.output.enableSSR ?? context.enableSSR,
-                        enableDevTools: ({ event, context })=>event.output.enableDevTools ?? context.enableDevTools,
-                        uiStyle: ({ event })=>event.output.uiStyle,
-                        expandedTheme: ({ event })=>event.output.expandedTheme ?? null
-                    })
-                },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Frontend options cancelled'
-                    })
-                }
-            }
-        },
-        scriptsOptions: {
-            invoke: {
-                src: "scriptsOption",
-                input: ({ context })=>({
-                        cliContext: context.cliContext
-                    }),
-                onDone: {
-                    target: 'fileGeneration',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        addScripts: ({ event })=>event.output.addScripts,
-                        selectedScripts: ({ event })=>event.output.selectedScripts ?? [],
-                        dependenciesToAdd: ({ context, event })=>{
-                            const deps = [
-                                context.framework?.pkg ?? 'c15t'
-                            ];
-                            if (event.output.addScripts) deps.push("@c15t/scripts");
-                            if (context.enableDevTools) deps.push('@c15t/dev-tools');
-                            return deps;
-                        }
-                    })
-                },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Scripts option cancelled'
-                    })
-                }
-            }
-        },
-        fileGeneration: {
-            invoke: {
-                src: 'fileGeneration',
-                input: ({ context })=>({
-                        cliContext: context.cliContext,
-                        mode: context.selectedMode,
-                        backendURL: context.backendURL,
-                        useEnvFile: context.useEnvFile,
-                        proxyNextjs: context.proxyNextjs,
-                        enableSSR: context.enableSSR,
-                        enableDevTools: context.enableDevTools,
-                        uiStyle: context.uiStyle,
-                        expandedTheme: context.expandedTheme,
-                        selectedScripts: context.selectedScripts
-                    }),
-                onDone: {
-                    target: 'dependencyCheck',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        filesCreated: ({ event })=>event.output.filesCreated,
-                        filesModified: ({ event })=>event.output.filesModified
-                    })
-                },
-                onError: {
-                    target: 'error',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        errors: ({ context, event })=>[
-                                ...context.errors,
-                                {
-                                    state: 'fileGeneration',
-                                    error: event.error,
-                                    timestamp: Date.now()
-                                }
-                            ]
-                    })
-                }
-            }
-        },
-        dependencyCheck: {
-            invoke: {
-                src: 'checkDependencies',
-                input: ({ context })=>({
-                        projectRoot: context.cliContext.projectRoot,
-                        dependencies: context.dependenciesToAdd
-                    }),
-                onDone: {
-                    target: 'dependencyConfirm',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        dependenciesToAdd: ({ event })=>event.output.missing
-                    })
-                },
-                onError: {
-                    target: 'dependencyConfirm'
-                }
-            }
-        },
-        dependencyConfirm: {
-            always: [
-                {
-                    guard: ({ context })=>0 === context.dependenciesToAdd.length,
-                    target: 'summary'
-                }
-            ],
-            invoke: {
-                src: 'installConfirm',
-                input: ({ context })=>({
-                        dependencies: context.dependenciesToAdd,
-                        packageManager: context.packageManager?.name ?? 'npm'
-                    }),
-                onDone: [
-                    {
-                        guard: ({ event })=>event.output.confirmed,
-                        target: 'dependencyInstall',
-                        actions: (0, __rspack_external_xstate.assign)({
-                            installConfirmed: true
-                        })
-                    },
-                    {
-                        target: 'summary',
-                        actions: (0, __rspack_external_xstate.assign)({
-                            installConfirmed: false
-                        })
-                    }
-                ],
-                onError: {
-                    target: 'summary',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        installConfirmed: false
-                    })
-                }
-            }
-        },
-        dependencyInstall: {
-            invoke: {
-                src: 'dependencyInstall',
-                input: ({ context })=>({
-                        cliContext: context.cliContext,
-                        dependencies: context.dependenciesToAdd
-                    }),
-                onDone: {
-                    target: 'summary',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        installAttempted: true,
-                        installSucceeded: ({ event })=>event.output.success
-                    })
-                },
-                onError: {
-                    target: 'summary',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        installAttempted: true,
-                        installSucceeded: false
-                    })
-                }
-            }
-        },
-        summary: {
-            entry: ({ context })=>{
-                if (!context.cliContext) return;
-                const { logger, packageManager } = context.cliContext;
-                if ('self-hosted' === context.selectedMode) {
-                    logger.info('Setup your backend with the c15t docs:');
-                    logger.info('https://c15t.com/docs/self-host/v2');
-                } else if ('custom' === context.selectedMode) logger.info('Configuration Complete! Implement your custom endpoint handlers.');
-                if (context.installConfirmed && !context.installSucceeded) logger.warn('Dependency installation failed. Please check errors and install manually.');
-                else if (!context.installConfirmed && context.dependenciesToAdd.length > 0) {
-                    const pmCommand = getManualInstallCommand(context.dependenciesToAdd, packageManager.name);
-                    logger.warn(`Run ${pmCommand} to install required dependencies.`);
-                }
-            },
-            after: {
-                100: 'githubStar'
-            }
-        },
-        githubStar: {
-            invoke: {
-                src: 'githubStar',
-                input: ({ context })=>({
-                        cliContext: context.cliContext
-                    }),
-                onDone: 'complete',
-                onError: 'complete'
-            }
-        },
-        complete: {
-            entry: ({ context })=>{
-                context.cliContext?.logger.success('Setup completed successfully!');
-            },
-            type: 'final'
-        },
-        error: {
-            entry: ({ context })=>{
-                const lastError = context.errors[context.errors.length - 1];
-                context.cliContext?.logger.error(`Error: ${lastError?.error?.message ?? 'Unknown error'}`);
-            },
-            always: [
-                {
-                    guard: 'hasFilesToRollback',
-                    target: 'rollback'
-                },
-                {
-                    target: 'exited'
-                }
-            ]
-        },
-        cancelling: {
-            entry: ({ context })=>{
-                context.cliContext?.logger.info(context.cancelReason ?? 'Configuration cancelled.');
-            },
-            always: [
-                {
-                    guard: 'hasFilesToRollback',
-                    target: 'rollback'
-                },
-                {
-                    target: 'exited'
-                }
-            ]
-        },
-        rollback: {
-            invoke: {
-                src: 'rollback',
-                input: ({ context })=>({
-                        filesCreated: context.filesCreated,
-                        filesModified: context.filesModified
-                    }),
-                onDone: {
-                    target: 'exited',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        filesCreated: [],
-                        filesModified: [],
-                        cleanupDone: true
-                    })
-                },
-                onError: {
-                    target: 'exited',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cleanupDone: true
-                    })
-                }
-            }
-        },
-        exited: {
-            type: 'final'
-        }
-    }
-});
-async function runGenerateMachine(options) {
-    const { context: cliContext, modeArg, resume = false, debug = false, persist = true } = options;
-    const { logger, telemetry } = cliContext;
-    const startTime = Date.now();
-    const persistPath = getPersistPath(cliContext.projectRoot);
-    const machineId = 'generate';
-    let snapshot;
-    if (resume) {
-        const hasPersisted = await hasPersistedState(persistPath);
-        if (hasPersisted) {
-            snapshot = await loadSnapshot(persistPath, machineId);
-            if (snapshot) logger.info('Resuming from previous state...');
-        }
-    }
-    const actor = (0, __rspack_external_xstate.createActor)(generateMachine, {
-        input: {
-            cliContext,
-            modeArg
-        },
-        ...snapshot ? {
-            snapshot: snapshot
-        } : {}
-    });
-    const subscribers = [];
-    subscribers.push(createTelemetrySubscriber({
-        telemetry,
-        machineId,
-        skipStates: [
-            'routeToMode'
-        ]
-    }));
-    if (debug) subscribers.push(createDebugSubscriber(machineId, logger));
-    if (persist) subscribers.push(createPersistenceSubscriber(machineId, persistPath));
-    const combinedSubscriber = combineSubscribers(...subscribers);
-    actor.subscribe((snapshot)=>combinedSubscriber(snapshot));
-    telemetry.trackEvent(TelemetryEventName.ONBOARDING_STARTED, {
-        resumed: resume && void 0 !== snapshot
-    });
-    telemetry.flushSync();
-    actor.start();
-    if (!snapshot) actor.send({
-        type: 'START'
-    });
-    return new Promise((resolve)=>{
-        actor.subscribe({
-            complete: ()=>{
-                const finalSnapshot = actor.getSnapshot();
-                const finalContext = finalSnapshot.context;
-                const finalState = String(finalSnapshot.value);
-                const duration = Date.now() - startTime;
-                clearSnapshot(persistPath).catch(()=>{});
-                const success = 'complete' === finalState || 'done' === finalSnapshot.status;
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
-                    success,
-                    selectedMode: finalContext.selectedMode ?? void 0,
-                    installDependencies: finalContext.installSucceeded,
-                    duration,
-                    finalState
-                });
-                resolve({
-                    success,
-                    context: finalContext,
-                    finalState,
-                    duration,
-                    errors: finalContext.errors
-                });
-            }
-        });
-    });
-}
-async function generateAction(context) {
-    const { logger, commandArgs, flags } = context;
-    const modeArg = commandArgs[0];
-    const resume = true === flags.resume;
-    const debug = true === flags.debug || 'debug' === flags.logger;
-    logger.debug('Starting generate command with state machine...');
-    logger.debug(`Mode arg: ${modeArg}`);
-    logger.debug(`Resume: ${resume}`);
-    try {
-        const result = await runGenerateMachine({
-            context,
-            modeArg,
-            resume,
-            debug,
-            persist: true
-        });
-        if (!result.success) {
-            if (result.errors.length > 0) process.exitCode = 1;
-        }
-    } catch (error) {
-        logger.error(`Generate command failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-}
-async function generate(context, mode) {
-    if (mode) context.commandArgs = [
-        mode
-    ];
-    return generateAction(context);
-}
-var utils_logger = __webpack_require__("./src/utils/logger.ts");
-async function addAndInstallDependenciesViaPM(projectRoot, dependencies, packageManager) {
-    if (0 === dependencies.length) return;
-    let command = '';
-    let args = [];
-    switch(packageManager){
-        case 'npm':
-            command = 'npm';
-            args = [
-                'install',
-                ...dependencies
-            ];
-            break;
-        case 'yarn':
-            command = 'yarn';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        case 'pnpm':
-            command = 'pnpm';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        case 'bun':
-            command = 'bun';
-            args = [
-                'add',
-                ...dependencies
-            ];
-            break;
-        default:
-            throw new Error(`Unsupported package manager for dependency addition: ${packageManager}`);
-    }
-    const child = (0, __rspack_external_node_child_process_27f17141.spawn)(command, args, {
-        cwd: projectRoot,
-        stdio: 'inherit'
-    });
-    await (0, __rspack_external_node_events_0a6aefe7.once)(child, 'exit');
-}
-function dependencies_getManualInstallCommand(dependencies, packageManager) {
-    switch(packageManager){
-        case 'npm':
-            return `npm install ${dependencies.join(' ')}`;
-        case 'yarn':
-            return `yarn add ${dependencies.join(' ')}`;
-        case 'pnpm':
-            return `pnpm add ${dependencies.join(' ')}`;
-        case 'bun':
-            return `bun add ${dependencies.join(' ')}`;
-        default:
-            return `npm install ${dependencies.join(' ')}`;
-    }
-}
-async function installDependencies({ context, dependenciesToAdd, handleCancel, autoInstall = false }) {
-    const { telemetry, logger } = context;
-    const s = prompts_.spinner();
-    if (0 === dependenciesToAdd.length) return {
-        installDepsConfirmed: false,
-        ranInstall: false
-    };
-    const depsString = dependenciesToAdd.map((d)=>external_picocolors_["default"].cyan(d)).join(', ');
-    if (!autoInstall) {
-        const addDepsSelection = await prompts_.confirm({
-            message: `Add required dependencies using ${external_picocolors_["default"].cyan(context.packageManager.name)}? (${depsString})`,
-            initialValue: true
-        });
-        if (handleCancel?.(addDepsSelection)) return {
-            installDepsConfirmed: false,
-            ranInstall: false
-        };
-        if (!addDepsSelection) return {
-            installDepsConfirmed: false,
-            ranInstall: false
-        };
-    }
-    s.start(`Running ${external_picocolors_["default"].cyan(context.packageManager.name)} to add and install dependencies... (this might take a moment)`);
-    try {
-        await addAndInstallDependenciesViaPM(context.projectRoot, dependenciesToAdd, context.packageManager.name);
-        s.stop(`✅ Dependencies installed: ${dependenciesToAdd.map((d)=>external_picocolors_["default"].cyan(d)).join(', ')}`);
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
-            success: true,
-            dependencies: dependenciesToAdd.join(','),
-            packageManager: context.packageManager.name
-        });
-        return {
-            installDepsConfirmed: true,
-            ranInstall: true
-        };
-    } catch (installError) {
-        s.stop(external_picocolors_["default"].yellow('⚠️ Dependency installation failed.'));
-        logger.error('Installation Error:', installError);
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
-            success: false,
-            error: installError instanceof Error ? installError.message : String(installError),
-            dependencies: dependenciesToAdd.join(','),
-            packageManager: context.packageManager.name
-        });
-        const pmCommand = dependencies_getManualInstallCommand(dependenciesToAdd, context.packageManager.name);
-        logger.info(`Please try running '${pmCommand}' manually in ${external_picocolors_["default"].cyan(external_node_path_["default"].relative(context.cwd, context.projectRoot))}.`);
-        return {
-            installDepsConfirmed: true,
-            ranInstall: false
-        };
-    }
-}
-var promises_ = __webpack_require__("node:fs/promises");
-const ADAPTER_LABELS = {
-    kyselyAdapter: 'kysely',
-    drizzleAdapter: 'drizzle',
-    prismaAdapter: 'prisma',
-    typeormAdapter: 'typeorm',
-    mongoAdapter: 'mongo'
-};
-const PROVIDERS_BY_ADAPTER = {
-    kyselyAdapter: [
-        {
-            label: 'PostgreSQL',
-            value: 'postgresql'
-        },
-        {
-            label: 'MySQL',
-            value: 'mysql'
-        },
-        {
-            label: 'SQLite',
-            value: 'sqlite'
-        },
-        {
-            label: 'CockroachDB',
-            value: 'cockroachdb'
-        },
-        {
-            label: 'Microsoft SQL Server',
-            value: 'mssql'
-        }
-    ],
-    drizzleAdapter: [
-        {
-            label: 'PostgreSQL',
-            value: 'postgresql'
-        },
-        {
-            label: 'MySQL',
-            value: 'mysql'
-        },
-        {
-            label: 'SQLite',
-            value: 'sqlite'
-        }
-    ],
-    prismaAdapter: [
-        {
-            label: 'PostgreSQL',
-            value: 'postgresql'
-        },
-        {
-            label: 'MySQL',
-            value: 'mysql'
-        },
-        {
-            label: 'SQLite',
-            value: 'sqlite'
-        },
-        {
-            label: 'MongoDB',
-            value: 'mongodb'
-        }
-    ],
-    typeormAdapter: [
-        {
-            label: 'PostgreSQL',
-            value: 'postgresql'
-        },
-        {
-            label: 'MySQL',
-            value: 'mysql'
-        },
-        {
-            label: 'SQLite',
-            value: 'sqlite'
-        },
-        {
-            label: 'SQL Server',
-            value: 'mssql'
-        }
-    ],
-    mongoAdapter: [
-        {
-            label: 'MongoDB',
-            value: 'mongodb'
-        }
-    ]
-};
-class Cancelled extends Error {
-    stage;
-    constructor(stage){
-        super('Operation cancelled.');
-        this.stage = stage;
-    }
-}
-const CONFIG_BUILDERS = {
-    kyselyAdapter: (provider)=>`kyselyAdapter({ provider: '${provider}', db })`,
-    drizzleAdapter: (provider)=>`drizzleAdapter({ provider: '${provider}', db })`,
-    prismaAdapter: (provider)=>`prismaAdapter({ provider: '${provider}', prisma })`,
-    typeormAdapter: (provider)=>`typeormAdapter({ provider: '${provider}', source })`,
-    mongoAdapter: ()=>'mongoAdapter({ client })'
-};
-async function pathExists(filePath) {
-    try {
-        await promises_["default"].access(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function buildDatabaseConfig(adapter, provider, connection) {
-    const builder = CONFIG_BUILDERS[adapter];
-    return builder(provider, connection);
-}
-function buildKyselyPrelude(provider, connection) {
-    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
-    if ('postgresql' === provider || 'cockroachdb' === provider) return {
-        imports: "import { Kysely, PostgresDialect } from 'kysely';\nimport { Pool } from 'pg';",
-        prelude: `const db = new Kysely({\n\tdialect: new PostgresDialect({\n\t\tpool: new Pool({ connectionString: ${connExpr} }),\n\t}),\n});`
-    };
-    if ('mysql' === provider) return {
-        imports: "import { Kysely, MysqlDialect } from 'kysely';\nimport mysql from 'mysql2/promise';",
-        prelude: `const db = new Kysely({\n\tdialect: new MysqlDialect({\n\t\tpool: mysql.createPool(${connExpr}),\n\t}),\n});`
-    };
-    if ('mssql' === provider) return {
-        imports: "import { Kysely, MssqlDialect } from 'kysely';\nimport mssql from 'mssql';",
-        prelude: `const db = new Kysely({\n\tdialect: new MssqlDialect({\n\t\tpool: new mssql.ConnectionPool(${connExpr}),\n\t}),\n});`
-    };
-    return {
-        imports: '',
-        prelude: ''
-    };
-}
-function buildSqliteKyselyPrelude(file) {
-    return {
-        imports: "import { Kysely, SqliteDialect } from 'kysely';\nimport Database from 'better-sqlite3';",
-        prelude: `const db = new Kysely({\n\tdialect: new SqliteDialect({\n\t\tdatabase: new Database("${file}"),\n\t}),\n});`
-    };
-}
-function buildDrizzlePrelude(provider, connection) {
-    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
-    if ('postgresql' === provider) return {
-        imports: "import { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool } from 'pg';",
-        prelude: `const db = drizzle(new Pool({ connectionString: ${connExpr} }));`
-    };
-    if ('mysql' === provider) return {
-        imports: "import { drizzle } from 'drizzle-orm/mysql2';\nimport mysql from 'mysql2/promise';",
-        prelude: `const db = drizzle(await mysql.createConnection(${connExpr}));`
-    };
-    if ('sqlite' === provider) {
-        const file = connection.sqliteFile || './db.sqlite';
-        return {
-            imports: "import { drizzle } from 'drizzle-orm/better-sqlite3';\nimport Database from 'better-sqlite3';",
-            prelude: `const db = drizzle(new Database("${file}"));`
-        };
-    }
-    return {
-        imports: '',
-        prelude: ''
-    };
-}
-function buildPrismaPrelude(_provider, _connection) {
-    return {
-        imports: "import { PrismaClient } from '@prisma/client';",
-        prelude: 'const prisma = new PrismaClient();'
-    };
-}
-function buildTypeormPrelude(provider, connection) {
-    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
-    if ('sqlite' === provider) {
-        const file = connection.sqliteFile || './db.sqlite';
-        return {
-            imports: "import { DataSource } from 'typeorm';",
-            prelude: `const source = new DataSource({ type: 'sqlite', database: "${file}" });`
-        };
-    }
-    const typeMap = {
-        postgresql: 'postgres',
-        mysql: 'mysql',
-        mssql: 'mssql'
-    };
-    return {
-        imports: "import { DataSource } from 'typeorm';",
-        prelude: `const source = new DataSource({ type: '${typeMap[String(provider)]}', url: ${connExpr} });`
-    };
-}
-function buildMongoPrelude(connection) {
-    const urlExpr = connection.useEnv ? `process.env.${connection.envVar || 'MONGODB_URI'}!` : `"${connection.value || ''}"`;
-    return {
-        imports: "import { MongoClient } from 'mongodb';",
-        prelude: `const client = new MongoClient(${urlExpr});`
-    };
-}
-function buildFileContent(adapter, provider, dbConfig, connection) {
-    const adapterPath = 'mongoAdapter' === adapter ? 'mongo' : adapter.replace('Adapter', '');
-    const importAdapter = `import { ${adapter} } from '@c15t/backend/db/adapters/${adapterPath}';`;
-    let extras = {
-        imports: '',
-        prelude: ''
-    };
-    if ('kyselyAdapter' === adapter) if ('sqlite' === provider) {
-        const file = connection.sqliteFile || './db.sqlite';
-        extras = buildSqliteKyselyPrelude(file);
-    } else extras = buildKyselyPrelude(provider, connection);
-    else if ('drizzleAdapter' === adapter) extras = buildDrizzlePrelude(provider, connection);
-    else if ('prismaAdapter' === adapter) extras = buildPrismaPrelude(provider, connection);
-    else if ('typeormAdapter' === adapter) extras = buildTypeormPrelude(provider, connection);
-    else if ('mongoAdapter' === adapter) extras = buildMongoPrelude(connection);
-    return `import { defineConfig } from '@c15t/backend';
-${importAdapter}
-${extras.imports ? `${extras.imports}\n` : ''}
-${extras.prelude ? `${extras.prelude}\n` : ''}
-export default defineConfig({
-	adapter: ${dbConfig},
-});
-`;
-}
-async function promptSelectAdapter() {
-    const selection = await prompts_.select({
-        message: 'Select database adapter:',
-        options: Object.keys(ADAPTER_LABELS).map((key)=>({
-                value: key,
-                label: ADAPTER_LABELS[key]
-            }))
-    });
-    if (prompts_.isCancel(selection)) throw new Cancelled('adapter_select');
-    return selection;
-}
-async function promptSelectProvider(adapter) {
-    const providers = PROVIDERS_BY_ADAPTER[adapter];
-    if (0 === providers.length) throw new Error('No providers available for selected adapter');
-    if (1 === providers.length) {
-        const [first] = providers;
-        return first.value;
-    }
-    const selection = await prompts_.select({
-        message: 'Select database provider:',
-        options: providers.map((opt)=>({
-                value: opt.value,
-                label: opt.label
-            }))
-    });
-    if (prompts_.isCancel(selection)) throw new Cancelled('provider_select');
-    return selection;
-}
-async function promptConnection(adapter, provider) {
-    const connection = {
-        useEnv: true
-    };
-    if ('sqlite' === provider) {
-        const sqliteFile = await prompts_.text({
-            message: 'SQLite file path:',
-            initialValue: './db.sqlite'
-        });
-        if (prompts_.isCancel(sqliteFile)) throw new Cancelled('sqlite_path');
-        connection.sqliteFile = String(sqliteFile);
-        return connection;
-    }
-    const useEnv = await prompts_.confirm({
-        message: 'Store connection string in an environment variable?',
-        initialValue: true
-    });
-    if (prompts_.isCancel(useEnv)) throw new Cancelled('use_env_confirm');
-    connection.useEnv = Boolean(useEnv);
-    if (connection.useEnv) {
-        const defaultVar = 'mongoAdapter' === adapter ? 'MONGODB_URI' : 'DATABASE_URL';
-        const envVarName = await prompts_.text({
-            message: 'Env var name for connection string:',
-            initialValue: defaultVar
-        });
-        if (prompts_.isCancel(envVarName)) throw new Cancelled('env_var_name');
-        connection.envVar = String(envVarName);
-        return connection;
-    }
-    const placeholder = 'mongoAdapter' === adapter ? 'mongodb+srv://user:pass@host/db' : 'postgresql://user:pass@host:5432/db';
-    const connectionString = await prompts_.text({
-        message: 'Connection string:',
-        placeholder
-    });
-    if (prompts_.isCancel(connectionString)) throw new Cancelled('connection_string');
-    connection.value = String(connectionString);
-    return connection;
-}
-async function ensureBackendConfig(context) {
-    const { cwd, logger } = context;
-    const targetPath = external_node_path_["default"].join(cwd, 'c15t-backend.config.ts');
-    if (await pathExists(targetPath)) {
-        logger.debug(`Backend config already exists at ${targetPath}`);
-        return {
-            path: targetPath,
-            dependencies: []
-        };
-    }
-    try {
-        const adapter = await promptSelectAdapter();
-        const provider = await promptSelectProvider(adapter);
-        const connection = await promptConnection(adapter, provider);
-        const dependencies = [];
-        if ('kyselyAdapter' === adapter) {
-            dependencies.push('kysely');
-            if ('postgresql' === provider || 'cockroachdb' === provider) dependencies.push('pg');
-            else if ('mysql' === provider) dependencies.push('mysql2');
-            else if ('mssql' === provider) dependencies.push('mssql');
-            else if ('sqlite' === provider) dependencies.push('better-sqlite3');
-        } else if ('drizzleAdapter' === adapter) {
-            dependencies.push('drizzle-orm');
-            if ('postgresql' === provider) dependencies.push('pg');
-            else if ('mysql' === provider) dependencies.push('mysql2');
-            else if ('sqlite' === provider) dependencies.push('better-sqlite3');
-        } else if ('prismaAdapter' === adapter) dependencies.push('@prisma/client');
-        else if ('typeormAdapter' === adapter) dependencies.push('typeorm');
-        else if ('mongoAdapter' === adapter) dependencies.push('mongodb');
-        const dbConfig = buildDatabaseConfig(adapter, provider, connection);
-        const fileContent = buildFileContent(adapter, String(provider), dbConfig, connection);
-        await promises_["default"].writeFile(targetPath, fileContent, 'utf8');
-        context.logger.success(`Created ${external_node_path_["default"].relative(cwd, targetPath)}`);
-        if ('sqlite' !== provider && connection.useEnv && connection.envVar) context.logger.note(`Remember to set ${connection.envVar} in your environment or .env file.`, 'Environment');
-        return {
-            path: targetPath,
-            dependencies
-        };
-    } catch (err) {
-        if (err instanceof Cancelled) return context.error.handleCancel('Operation cancelled.', {
-            command: 'ensure-backend-config',
-            stage: err.stage
-        });
-        throw err;
-    }
-}
-async function handleMigrationResult(context, result) {
-    const { logger, telemetry } = context;
-    telemetry.trackEvent(TelemetryEventName.MIGRATION_PLANNED, {
-        success: true
-    });
-    const saveSQL = await prompts_.confirm({
-        message: 'Save SQL to file?',
-        initialValue: true
-    });
-    if (prompts_.isCancel(saveSQL)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
-        saveSql: false
-    });
-    if (saveSQL) {
-        const sql = result.getSQL?.() ?? '';
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const filename = `migration-${timestamp}.sql`;
-        const filepath = (0, external_node_path_.join)(process.cwd(), filename);
-        await (0, promises_.writeFile)(filepath, sql, 'utf-8');
-        logger.success(`SQL saved to: ${filename}`);
-    }
-    const execute = await prompts_.confirm({
-        message: 'Execute this migration?',
-        initialValue: false
-    });
-    if (prompts_.isCancel(execute)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
-        execute: false
-    });
-    await result.execute();
-    logger.success('Migration completed.');
-    telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
-        success: true
-    });
-}
-async function handleORMResult(context, result) {
-    const { logger, telemetry, cwd } = context;
-    const filePath = external_node_path_["default"].join(cwd, result.path);
-    await promises_["default"].mkdir(external_node_path_["default"].dirname(filePath), {
-        recursive: true
-    });
-    await promises_["default"].writeFile(filePath, result.code);
-    logger.info(`Migration file created at ${filePath}`);
-    telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
-        success: true,
-        migrationFileCreated: true
-    });
-}
-async function readConfigAndGetDb(context, absoluteConfigPath) {
-    const { logger } = context;
-    logger.info(`Loading backend config from ${absoluteConfigPath}`);
-    const resolvedPath = external_node_path_["default"].resolve(absoluteConfigPath);
-    try {
-        await promises_["default"].access(resolvedPath);
-    } catch  {
-        throw new Error(`Backend config not found at: ${resolvedPath}`);
-    }
-    try {
-        const { config } = await (0, __rspack_external_c12.loadConfig)({
-            configFile: absoluteConfigPath,
-            jitiOptions: {
-                extensions: [
-                    '.ts',
-                    '.tsx',
-                    '.js',
-                    '.jsx',
-                    '.mjs',
-                    '.cjs',
-                    '.mts',
-                    '.cts',
-                    '.cjs'
-                ]
-            }
-        });
-        logger.debug('Imported Config');
-        if (!config || 'object' != typeof config || !('adapter' in config)) throw new Error('Invalid backend config: missing required "adapter" property');
-        return {
-            db: __rspack_external__c15t_backend_db_schema_e7c5e6a0.DB.client(config.adapter)
-        };
-    } catch (error) {
-        logger.error('Failed to load backend config', error);
-        if (error instanceof Error) throw error;
-        throw new Error(`Unknown error loading backend config: ${String(error)}`);
-    }
-}
-async function migrate(context) {
-    const { logger } = context;
-    logger.info('Starting migration process...');
-    const configResult = await ensureBackendConfig(context);
-    if (!configResult || !configResult.path) return void logger.error('No backend config found.');
-    const { path, dependencies } = configResult;
-    if (dependencies.length > 0) await installDependencies({
-        context,
-        dependenciesToAdd: dependencies,
-        autoInstall: true
-    });
-    const { db } = await readConfigAndGetDb(context, path);
-    logger.info('Loaded c15t-backend.config.ts');
-    const result = await (0, __rspack_external__c15t_backend_db_migrator_ebe6d5c7.migrator)({
-        db,
-        schema: 'latest'
-    });
-    if ('path' in result) await handleORMResult(context, result);
-    else await handleMigrationResult(context, result);
-}
-const subcommands = [
-    {
-        name: 'generate',
-        label: 'Generate',
-        hint: 'Generate code for your c15t project',
-        action: generate
-    },
-    {
-        name: 'migrate',
-        label: 'Migrate',
-        hint: 'Run database migrations',
-        action: migrate
-    }
-];
-async function selfHost(context) {
-    const { logger, telemetry, commandArgs, error } = context;
-    logger.debug('Starting self-host command...');
-    telemetry.trackEvent(TelemetryEventName.SELF_HOST_STARTED, {});
-    const [subcommand] = commandArgs;
-    if (subcommand) {
-        switch(subcommand){
-            case 'generate':
-                await generate(context, 'self-hosted');
-                break;
-            case 'migrate':
-                await migrate(context);
-                break;
-            default:
-                logger.error(`Unknown self-host subcommand: ${subcommand}`);
-                logger.info('Available subcommands: generate, migrate');
-                telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
-                    success: false,
-                    reason: 'unknown_subcommand'
-                });
-                break;
-        }
-        return;
-    }
-    logger.debug('No subcommand specified, entering interactive selection.');
-    telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_OPENED, {
-        context: 'self-host'
-    });
-    const promptOptions = subcommands.map((cmd)=>({
-            value: cmd.name,
-            label: cmd.label,
-            hint: cmd.hint
-        }));
-    promptOptions.push({
-        value: 'exit',
-        label: 'Exit',
-        hint: 'Return to main menu'
-    });
-    const selectedSubcommandName = await prompts_.select({
-        message: (0, utils_logger.$e)('info', 'Which self-host command would you like to run?'),
-        options: promptOptions
-    });
-    if (prompts_.isCancel(selectedSubcommandName) || 'exit' === selectedSubcommandName) {
-        logger.debug('Interactive selection cancelled or exit chosen.');
-        telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-            action: prompts_.isCancel(selectedSubcommandName) ? 'cancelled' : 'exit',
-            context: 'self-host'
-        });
-        error.handleCancel('Operation cancelled.', {
-            command: 'self-host',
-            stage: 'menu_selection'
-        });
-        return;
-    }
-    const selectedSubcommand = subcommands.find((cmd)=>cmd.name === selectedSubcommandName);
-    if (selectedSubcommand) {
-        logger.debug(`User selected subcommand: ${selectedSubcommand.name}`);
-        if ('generate' === selectedSubcommand.name) await generate(context, 'self-hosted');
-        else await selectedSubcommand.action(context);
-    } else {
-        logger.error(`Unknown subcommand: ${selectedSubcommandName}`);
-        telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
-            success: false,
-            reason: 'invalid_selection'
-        });
-        return;
-    }
-    telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
-        success: true
-    });
-}
-async function displayIntro(context, version) {
-    const { logger } = context;
-    logger.info(`${external_picocolors_["default"].bold('Welcome!')} Let's get you set up.`);
-    logger.message('');
-    let figletText = 'c15t';
-    try {
-        figletText = await new Promise((resolve)=>{
-            __rspack_external_figlet["default"].text('c15t', {
-                font: 'Nancyj-Improved',
-                horizontalLayout: 'default',
-                verticalLayout: 'default',
-                width: 80,
-                whitespaceBreak: true
-            }, (err, data)=>{
-                if (err) {
-                    logger.debug('Failed to generate figlet text');
-                    resolve('c15t');
-                } else resolve(data || 'c15t');
-            });
-        });
-    } catch (error) {
-        logger.debug('Error generating figlet text', error);
-    }
-    const customColor = {
-        teal10: (text)=>`\x1b[38;2;10;80;70m${text}\x1b[0m`,
-        teal20: (text)=>`\x1b[38;2;15;100;90m${text}\x1b[0m`,
-        teal30: (text)=>`\x1b[38;2;20;120;105m${text}\x1b[0m`,
-        teal40: (text)=>`\x1b[38;2;25;150;130m${text}\x1b[0m`,
-        teal50: (text)=>`\x1b[38;2;30;170;150m${text}\x1b[0m`,
-        teal75: (text)=>`\x1b[38;2;34;211;187m${text}\x1b[0m`,
-        teal90: (text)=>`\x1b[38;2;45;225;205m${text}\x1b[0m`,
-        teal100: (text)=>`\x1b[38;2;65;235;220m${text}\x1b[0m`
-    };
-    const lines = figletText.split('\n');
-    const coloredLines = lines.map((line, index)=>{
-        const position = index / (lines.length - 1);
-        if (position < 0.1) return customColor.teal10(line);
-        if (position < 0.2) return customColor.teal20(line);
-        if (position < 0.3) return customColor.teal30(line);
-        if (position < 0.4) return customColor.teal40(line);
-        if (position < 0.5) return customColor.teal50(line);
-        if (position < 0.65) return customColor.teal75(line);
-        if (position < 0.8) return customColor.teal90(line);
-        return customColor.teal100(line);
-    });
-    logger.message(coloredLines.join('\n'));
-}
-var constants = __webpack_require__("./src/constants.ts");
-function createErrorHandlers(context) {
-    const { logger, telemetry } = context;
-    return {
-        handleError: (error, message)=>{
-            logger.error(message, error);
-            if (error instanceof Error) logger.error(error.message);
-            else logger.error(String(error));
-            logger.failed(`${external_picocolors_["default"].red('Operation failed unexpectedly.')}`);
-            process.exit(1);
-        },
-        handleCancel: (message = 'Operation cancelled.', context)=>{
-            logger.debug(`Handling cancellation: ${message}`, context);
-            telemetry.trackEvent(TelemetryEventName.ONBOARDING_EXITED, {
-                reason: 'user_cancelled',
-                command: context?.command || 'unknown',
-                stage: context?.stage || 'unknown'
-            });
-            logger.failed(message);
-            process.exit(0);
-        }
-    };
-}
-function createFileSystem(context) {
-    const { logger, cwd } = context;
-    return {
-        getPackageInfo: ()=>{
-            logger.debug('Reading package.json');
-            const packageJsonPath = external_node_path_["default"].join(cwd, 'package.json');
-            logger.debug(`package.json path: ${packageJsonPath}`);
-            try {
-                const packageInfo = __rspack_external_fs_extra_ce68a66b["default"].readJSONSync(packageJsonPath);
-                logger.debug('Successfully read package.json');
-                return {
-                    name: packageInfo?.name || 'unknown',
-                    version: packageInfo?.version || 'unknown',
-                    ...packageInfo
-                };
-            } catch (error) {
-                logger.error(`Error reading package.json at ${packageJsonPath}:`, error);
-                return {
-                    name: 'unknown',
-                    version: 'unknown'
-                };
-            }
-        }
-    };
-}
-async function detectFramework(projectRoot, logger) {
-    try {
-        logger?.debug(`Detecting framework in ${projectRoot}`);
-        const packageJsonPath = external_node_path_["default"].join(projectRoot, 'package.json');
-        const packageJson = JSON.parse(await promises_["default"].readFile(packageJsonPath, 'utf-8'));
-        const deps = {
-            ...packageJson.dependencies,
-            ...packageJson.devDependencies
-        };
-        const hasReact = 'react' in deps;
-        const reactVersion = hasReact ? deps.react : null;
-        logger?.debug(`React detected: ${hasReact}${reactVersion ? ` (version: ${reactVersion})` : ''}`);
-        const tailwindVersion = deps.tailwindcss || null;
-        logger?.debug(`Tailwind detected: ${!!tailwindVersion}${tailwindVersion ? ` (version: ${tailwindVersion})` : ''}`);
-        let framework = null;
-        let frameworkVersion = null;
-        let pkg = hasReact ? '@c15t/react' : 'c15t';
-        if ('next' in deps) {
-            framework = 'Next.js';
-            frameworkVersion = deps.next;
-            pkg = '@c15t/nextjs';
-        } else if ('@remix-run/react' in deps) {
-            framework = 'Remix';
-            frameworkVersion = deps['@remix-run/react'];
-        } else if ('@vitejs/plugin-react' in deps || '@vitejs/plugin-react-swc' in deps) {
-            framework = 'Vite + React';
-            frameworkVersion = deps['@vitejs/plugin-react'] || deps['@vitejs/plugin-react-swc'];
-        } else if ('gatsby' in deps) {
-            framework = 'Gatsby';
-            frameworkVersion = deps.gatsby;
-        } else if (hasReact) {
-            framework = 'React';
-            frameworkVersion = reactVersion;
-        }
-        logger?.debug(`Detected framework: ${framework}${frameworkVersion ? ` (version: ${frameworkVersion})` : ''}, package: ${pkg}`);
-        return {
-            framework,
-            frameworkVersion,
-            pkg,
-            hasReact,
-            reactVersion,
-            tailwindVersion
-        };
-    } catch (error) {
-        logger?.debug(`Framework detection failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            framework: null,
-            frameworkVersion: null,
-            pkg: 'c15t',
-            hasReact: false,
-            reactVersion: null,
-            tailwindVersion: null
-        };
-    }
-}
-async function detectProjectRoot(cwd, logger) {
-    let projectRoot = cwd;
-    logger?.debug(`Starting project root detection from: ${cwd}`);
-    try {
-        let prevDir = '';
-        let depth = 0;
-        const maxDepth = 10;
-        while(projectRoot !== prevDir && depth < maxDepth){
-            logger?.debug(`Checking directory (depth ${depth}): ${projectRoot}`);
-            try {
-                const packageJsonPath = external_node_path_["default"].join(projectRoot, 'package.json');
-                logger?.debug(`Looking for package.json at: ${packageJsonPath}`);
-                await promises_["default"].access(packageJsonPath);
-                logger?.debug(`Found package.json at: ${projectRoot}`);
-                break;
-            } catch (error) {
-                logger?.debug(`No package.json found in ${projectRoot}: ${error instanceof Error ? error.message : String(error)}`);
-                prevDir = projectRoot;
-                projectRoot = external_node_path_["default"].dirname(projectRoot);
-                depth++;
-            }
-        }
-        if (projectRoot === prevDir) {
-            logger?.debug('Reached root directory without finding package.json');
-            logger?.failed('Could not find project root (no package.json found)');
-        }
-        if (depth >= maxDepth) {
-            logger?.debug('Reached maximum directory depth without finding package.json');
-            logger?.failed('Could not find project root (reached maximum directory depth)');
-        }
-        logger?.debug(`Project root detection complete. Found at: ${projectRoot}`);
-        return projectRoot;
-    } catch (error) {
-        logger?.debug(`Project root detection failed: ${error instanceof Error ? error.message : String(error)}`);
-        logger?.debug(`Falling back to current directory: ${cwd}`);
-        return cwd;
-    }
-}
-const SUPPORTED_PACKAGE_MANAGERS = [
-    'npm',
-    'yarn',
-    'pnpm',
-    'bun'
-];
-async function getPackageManagerVersion(pm) {
-    try {
-        const { execSync } = await import("node:child_process");
-        const version = execSync(`${pm} --version`).toString().trim();
-        return version;
-    } catch  {
-        return null;
-    }
-}
-async function detectPackageManager(projectRoot, logger) {
-    try {
-        logger?.debug('Detecting package manager');
-        const pm = await (0, __rspack_external_package_manager_detector_detect_94d6a9ae.detect)({
-            cwd: projectRoot
-        });
-        if (!pm) throw new Error('No package manager detected');
-        logger?.debug(`Detected package manager: ${pm.name}`);
-        if (!SUPPORTED_PACKAGE_MANAGERS.includes(pm.name)) throw new Error(`Unsupported package manager: ${pm.name}`);
-        return {
-            name: pm.name,
-            version: pm.version ?? null
-        };
-    } catch (error) {
-        logger?.error(`Error detecting package manager: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const selectedPackageManager = await prompts_.select({
-        message: 'Please select your package manager:',
-        options: [
-            {
-                value: 'npm',
-                label: 'npm'
-            },
-            {
-                value: 'yarn',
-                label: 'yarn'
-            },
-            {
-                value: 'pnpm',
-                label: 'pnpm'
-            },
-            {
-                value: 'bun',
-                label: 'bun'
-            }
-        ],
-        initialValue: 'npm'
-    });
-    if (prompts_.isCancel(selectedPackageManager)) {
-        logger?.debug('Package manager selection cancelled by user');
-        logger?.failed('Package manager selection cancelled. Exiting.');
-        process.exit(0);
-    }
-    const version = await getPackageManagerVersion(selectedPackageManager);
-    logger?.debug(`User selected package manager: ${selectedPackageManager} (version: ${version ?? 'unknown'})`);
-    return {
-        name: selectedPackageManager,
-        version
-    };
-}
-const globalFlags = [
-    {
-        names: [
-            '--help',
-            '-h'
-        ],
-        description: 'Show this help message.',
-        type: 'special',
-        expectsValue: false
-    },
-    {
-        names: [
-            '--version',
-            '-v'
-        ],
-        description: 'Show the CLI version.',
-        type: 'special',
-        expectsValue: false
-    },
-    {
-        names: [
-            '--logger'
-        ],
-        description: 'Set log level (fatal, error, warn, info, debug).',
-        type: 'string',
-        expectsValue: true
-    },
-    {
-        names: [
-            '--config'
-        ],
-        description: 'Specify path to configuration file.',
-        type: 'string',
-        expectsValue: true
-    },
-    {
-        names: [
-            '-y'
-        ],
-        description: 'Skip confirmation prompts (use with caution).',
-        type: 'boolean',
-        expectsValue: false
-    },
-    {
-        names: [
-            '--no-telemetry'
-        ],
-        description: 'Disable telemetry data collection.',
-        type: 'boolean',
-        expectsValue: false
-    },
-    {
-        names: [
-            '--telemetry-debug'
-        ],
-        description: 'Enable debug mode for telemetry (shows detailed telemetry logs).',
-        type: 'boolean',
-        expectsValue: false
-    }
-];
-function parseCliArgs(rawArgs, commands) {
-    const parsedFlags = {};
-    const potentialCommandArgsAndUndefined = [];
-    let commandName;
-    const commandArgs = [];
-    for (const flag of globalFlags){
-        const primaryName = flag.names[0]?.replace(/^--/, '').replace(/^-/, '');
-        if (primaryName) parsedFlags[primaryName] = 'boolean' === flag.type ? false : void 0;
-    }
-    for(let i = 0; i < rawArgs.length; i++){
-        const arg = rawArgs[i];
-        if ('string' != typeof arg) continue;
-        let argIsFlagOrValue = false;
-        for (const flag of globalFlags)if (flag.names.includes(arg)) {
-            const primaryName = flag.names[0]?.replace(/^--/, '').replace(/^-/, '');
-            if (primaryName) {
-                argIsFlagOrValue = true;
-                if ('boolean' === flag.type) parsedFlags[primaryName] = true;
-                else if (flag.expectsValue) {
-                    const nextArg = rawArgs[i + 1];
-                    if (nextArg && !nextArg.startsWith('-')) {
-                        parsedFlags[primaryName] = nextArg;
-                        i++;
-                    } else prompts_.log.warn((0, utils_logger.$e)('warn', `Flag ${arg} expects a value, but none was found or the next item is a flag.`));
-                } else parsedFlags[primaryName] = true;
-            }
-            break;
-        }
-        if (!argIsFlagOrValue) potentialCommandArgsAndUndefined.push(arg);
-    }
-    const potentialCommandArgs = potentialCommandArgsAndUndefined.filter((arg)=>'string' == typeof arg);
-    commandName = potentialCommandArgs.find((arg)=>commands.some((cmd)=>cmd.name === arg));
-    for (const arg of potentialCommandArgs)if (arg !== commandName) commandArgs.push(arg);
-    return {
-        commandName,
-        commandArgs,
-        parsedFlags
-    };
-}
-function createUserInteraction(context) {
-    const { logger, error } = context;
-    return {
-        confirm: async (message, initialValue)=>{
-            logger.debug(`Confirm action: "${message}", Initial: ${initialValue}`);
-            const confirmed = await prompts_.confirm({
-                message,
-                initialValue
-            });
-            if (prompts_.isCancel(confirmed)) {
-                error.handleCancel();
-                return false;
-            }
-            logger.debug(`Confirmation result: ${confirmed}`);
-            return confirmed;
-        }
-    };
-}
-async function createCliContext(rawArgs, cwd, commands) {
-    const { commandName, commandArgs, parsedFlags } = parseCliArgs(rawArgs, commands);
-    let desiredLogLevel = 'info';
-    const levelArg = parsedFlags.logger;
-    if ('string' == typeof levelArg) if (utils_logger.U0.includes(levelArg)) desiredLogLevel = levelArg;
-    else console.warn(`[CLI Setup] Invalid log level '${levelArg}' provided via --logger. Using default 'info'.`);
-    else if (true === levelArg) console.warn("[CLI Setup] --logger flag found but no level specified. Using default 'info'.");
-    const logger = (0, utils_logger.xw)(desiredLogLevel);
-    logger.debug(`Logger initialized with level: ${desiredLogLevel}`);
-    const baseContext = {
-        logger,
-        flags: parsedFlags,
-        commandName,
-        commandArgs,
-        cwd
-    };
-    const context = baseContext;
-    context.error = createErrorHandlers(context);
-    const userInteraction = createUserInteraction(context);
-    context.confirm = userInteraction.confirm;
-    context.fs = createFileSystem(context);
-    context.projectRoot = await detectProjectRoot(cwd, logger);
-    context.framework = await detectFramework(context.projectRoot, logger);
-    context.packageManager = await detectPackageManager(context.projectRoot, logger);
-    const telemetryDisabled = true === parsedFlags['no-telemetry'];
-    const telemetryDebug = true === parsedFlags['telemetry-debug'];
-    try {
-        context.telemetry = createTelemetry({
-            disabled: telemetryDisabled,
-            debug: telemetryDebug,
-            defaultProperties: {
-                cliVersion: context.fs.getPackageInfo().version,
-                framework: context.framework.framework ?? 'unknown',
-                frameworkVersion: context.framework.frameworkVersion ?? 'unknown',
-                packageManager: context.packageManager.name,
-                packageManagerVersion: context.packageManager.version ?? 'unknown',
-                hasReact: context.framework.hasReact,
-                reactVersion: context.framework.reactVersion ?? 'unknown',
-                package: context.framework.pkg ?? 'unknown'
-            },
-            logger: context.logger
-        });
-        if (telemetryDisabled) logger.debug('Telemetry is disabled by user preference');
-        else if (telemetryDebug) logger.debug('Telemetry initialized with debug mode enabled');
-        else logger.debug('Telemetry initialized');
-    } catch  {
-        logger.warn('Failed to initialize telemetry, continuing with telemetry disabled');
-        context.telemetry = createTelemetry({
-            disabled: true,
-            logger: context.logger
-        });
-    }
-    logger.debug('CLI context fully initialized with all utilities');
-    return context;
-}
-const src_commands = [
-    {
-        name: 'generate',
-        label: 'Generate (Recommended)',
-        hint: 'Add c15t to your project',
-        description: 'Setup your c15t project',
-        action: (context)=>generate(context)
-    },
-    {
-        name: 'self-host',
-        label: 'Self Host',
-        hint: 'Host c15t backend on your own infra',
-        description: 'Commands for self-hosting c15t (generate, migrate).',
-        action: (context)=>selfHost(context)
-    },
-    {
-        name: 'github',
-        label: 'GitHub',
-        hint: 'Star us on GitHub',
-        description: 'Open our GitHub repository to give us a star.',
-        action: async (context)=>{
-            const { logger } = context;
-            logger.note(`We're building c15t as an ${external_picocolors_["default"].bold('open source')} project to make consent management more accessible.\nIf you find this useful, we'd really appreciate a GitHub star - it helps others discover the project!`, 'Star Us on GitHub');
-            await (0, __rspack_external_open["default"])(constants.tl.GITHUB);
-            logger.success('Thank you for your support!');
-        }
-    },
-    {
-        name: 'docs',
-        label: 'c15t docs',
-        hint: 'Open documentation',
-        description: 'Open the c15t documentation in your browser.',
-        action: async (context)=>{
-            const { logger } = context;
-            await (0, __rspack_external_open["default"])(`${constants.tl.DOCS}?ref=cli`);
-            logger.success('Documentation opened in your browser.');
-        }
-    }
-];
-async function main() {
-    const rawArgs = process.argv.slice(2);
-    const cwd = process.cwd();
-    const context = await createCliContext(rawArgs, cwd, src_commands);
-    const { logger, flags, commandName, commandArgs, error, telemetry } = context;
-    const packageInfo = context.fs.getPackageInfo();
-    const version = packageInfo.version;
-    if (!telemetry.isDisabled()) logger.note(`c15t collects anonymous usage data to help improve the CLI. 
-This data is not personally identifiable and helps us prioritize features.
-To disable telemetry, use the ${external_picocolors_["default"].cyan('--no-telemetry')}
-flag or set ${external_picocolors_["default"].cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.`, `${(0, utils_logger.$e)('info', 'Telemetry Notice')}`);
-    try {
-        telemetry.trackEvent(TelemetryEventName.CLI_INVOKED, {
-            version,
-            nodeVersion: process.version,
-            platform: process.platform
-        });
-        telemetry.flushSync();
-    } catch (error) {
-        logger.debug('Failed to track CLI invocation:', error);
-    }
-    if (flags.version) {
-        logger.debug('Version flag detected');
-        logger.message(`c15t CLI version ${version}`);
-        telemetry.trackEvent(TelemetryEventName.VERSION_DISPLAYED, {
-            version
-        });
-        telemetry.flushSync();
-        await telemetry.shutdown();
-        process.exit(0);
-    }
-    if (flags.help) {
-        logger.debug('Help flag detected. Displaying help and exiting.');
-        telemetry.trackEvent(TelemetryEventName.HELP_DISPLAYED, {
-            version
-        });
-        telemetry.flushSync();
-        showHelpMenu(context, version, src_commands, globalFlags);
-        await telemetry.shutdown();
-        process.exit(0);
-    }
-    logger.debug('Raw process arguments:', process.argv);
-    logger.debug('Parsed command name:', commandName);
-    logger.debug('Parsed command args:', commandArgs);
-    logger.debug('Parsed global flags:', flags);
-    await displayIntro(context, version);
-    logger.debug(`Current working directory: ${cwd}`);
-    logger.debug(`Config path flag: ${flags.config}`);
-    try {
-        if (commandName) {
-            const command = src_commands.find((cmd)=>cmd.name === commandName);
-            if (command) {
-                logger.info(`Executing command: ${command.name}`);
-                telemetry.trackCommand(command.name, commandArgs, flags);
-                await command.action(context);
-                telemetry.trackEvent(TelemetryEventName.COMMAND_SUCCEEDED, {
-                    command: command.name,
-                    executionTime: Date.now() - performance.now()
-                });
-                telemetry.flushSync();
-            } else {
-                logger.error(`Unknown command: ${commandName}`);
-                telemetry.trackEvent(TelemetryEventName.COMMAND_UNKNOWN, {
-                    unknownCommand: commandName
-                });
-                telemetry.flushSync();
-                logger.info('Run c15t --help to see available commands.');
-                await telemetry.shutdown();
-                process.exit(1);
-            }
-        } else {
-            logger.debug('No command specified, entering interactive selection.');
-            telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_OPENED, {});
-            const promptOptions = src_commands.map((cmd)=>({
-                    value: cmd.name,
-                    label: cmd.label,
-                    hint: cmd.hint
-                }));
-            promptOptions.push({
-                value: 'exit',
-                label: 'exit',
-                hint: 'Close the CLI'
-            });
-            const selectedCommandName = await prompts_.select({
-                message: (0, utils_logger.$e)('info', 'Which command would you like to run?'),
-                options: promptOptions
-            });
-            if (prompts_.isCancel(selectedCommandName) || 'exit' === selectedCommandName) {
-                logger.debug('Interactive selection cancelled or exit chosen.');
-                telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-                    action: prompts_.isCancel(selectedCommandName) ? 'cancelled' : 'exit'
-                });
-                context.error.handleCancel('Operation cancelled.', {
-                    command: 'interactive_menu',
-                    stage: 'exit'
-                });
-            } else {
-                const selectedCommand = src_commands.find((cmd)=>cmd.name === selectedCommandName);
-                if (selectedCommand) {
-                    logger.debug(`User selected command: ${selectedCommand.name}`);
-                    telemetry.trackCommand(selectedCommand.name, [], flags);
-                    await selectedCommand.action(context);
-                    telemetry.trackEvent(TelemetryEventName.COMMAND_SUCCEEDED, {
-                        command: selectedCommand.name,
-                        executionTime: Date.now() - performance.now()
-                    });
-                    telemetry.flushSync();
-                } else {
-                    telemetry.trackEvent(TelemetryEventName.COMMAND_UNKNOWN, {
-                        unknownCommand: String(selectedCommandName)
-                    });
-                    telemetry.flushSync();
-                    error.handleError(new Error(`Command '${selectedCommandName}' not found`), 'An internal error occurred');
-                }
-            }
-        }
-        logger.debug('Command execution completed');
-        telemetry.trackEvent(TelemetryEventName.CLI_COMPLETED, {
-            success: true
-        });
-        telemetry.flushSync();
-    } catch (executionError) {
-        telemetry.trackEvent(TelemetryEventName.COMMAND_FAILED, {
-            command: commandName,
-            error: executionError instanceof Error ? executionError.message : String(executionError)
-        });
-        telemetry.flushSync();
-        error.handleError(executionError, 'An unexpected error occurred during command execution');
-    }
-    await telemetry.shutdown();
-}
-main();
-export { main };
+export { main } from "./145.mjs";