@c15t/cli 1.8.3 → 2.0.0-rc.0

package/dist/index.mjs

@@ -1,24 +1,162 @@
 #!/usr/bin/env node
-import { confirm as prompts_confirm, isCancel, log as prompts_log, note, outro, select as prompts_select, spinner as prompts_spinner, text as prompts_text } from "@clack/prompts";
+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 open_0 from "open";
-import picocolors from "picocolors";
-import node_path, { join } from "node:path";
-import promises, { writeFile } from "node:fs/promises";
-import node_crypto from "node:crypto";
-import node_os from "node:os";
-import { PostHog } from "posthog-node";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import { createLogger } from "@c15t/logger";
-import { Node, Project, SyntaxKind } from "ts-morph";
-import { migrator } from "@c15t/backend/v2/db/migrator";
-import { DB } from "@c15t/backend/v2/db/schema";
-import { loadConfig } from "c12";
-import figlet from "figlet";
-import fs_extra from "fs-extra";
-import { detect } from "package-manager-detector/detect";
-var __webpack_require__ = {};
+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, {
@@ -27,31 +165,58 @@ var __webpack_require__ = {};
         });
     };
 })();
+(()=>{
+    __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);
 })();
 (()=>{
-    __webpack_require__.r = (exports)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports, '__esModule', {
-            value: true
-        });
+    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_namespaceObject = {};
-__webpack_require__.r(prompts_namespaceObject);
-__webpack_require__.d(prompts_namespaceObject, {
-    confirm: ()=>prompts_confirm,
-    isCancel: ()=>isCancel,
-    log: ()=>prompts_log,
-    note: ()=>note,
-    outro: ()=>outro,
-    select: ()=>prompts_select,
-    spinner: ()=>prompts_spinner,
-    text: ()=>prompts_text
-});
+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.');
@@ -69,101 +234,12 @@ ${commandLines}
 Options:
 ${optionLines}
 
-Run a command directly (e.g., ${picocolors.cyan('c15t generate')}) or select one interactively when no command is provided.
+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');
 }
-async function detectFramework(projectRoot, logger) {
-    try {
-        logger?.debug(`Detecting framework in ${projectRoot}`);
-        const packageJsonPath = node_path.join(projectRoot, 'package.json');
-        const packageJson = JSON.parse(await promises.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})` : ''}`);
-        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
-        };
-    } 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
-        };
-    }
-}
-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 = node_path.join(projectRoot, 'package.json');
-                logger?.debug(`Looking for package.json at: ${packageJsonPath}`);
-                await promises.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 = node_path.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 TELEMETRY_DISABLED_ENV = 'C15T_TELEMETRY_DISABLED';
 const TelemetryEventName = {
     CLI_INVOKED: 'cli.invoked',
@@ -203,7 +279,11 @@ const TelemetryEventName = {
     GENERATE_FAILED: 'generate.failed',
     SELF_HOST_STARTED: 'self-host.started',
     SELF_HOST_COMPLETED: 'self-host.completed',
-    SELF_HOST_FAILED: 'self-host.failed'
+    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;
@@ -338,7 +418,7 @@ class Telemetry {
                     requestTimeout: 3000
                 };
                 if (this.debug) this.logDebug('Initializing PostHog client with config:', JSON.stringify(clientConfig));
-                this.client = new PostHog(this.apiKey, 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) {
@@ -353,7 +433,7 @@ class Telemetry {
                 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 PostHog(this.apiKey);
+                    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) {
@@ -363,7 +443,7 @@ class Telemetry {
         }
     }
     generateAnonymousId() {
-        const machineId = node_crypto.createHash('sha256').update(node_os.hostname() + node_os.platform() + node_os.arch() + node_os.totalmem()).digest('hex');
+        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() {
@@ -379,10 +459,175 @@ class Telemetry {
 function createTelemetry(options) {
     return new Telemetry(options);
 }
-async function addAndInstallDependenciesViaPM(projectRoot, dependencies, packageManager) {
+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 = [];
+    let command;
+    let args;
     switch(packageManager){
         case 'npm':
             command = 'npm';
@@ -413,14 +658,40 @@ async function addAndInstallDependenciesViaPM(projectRoot, dependencies, package
             ];
             break;
         default:
-            throw new Error(`Unsupported package manager for dependency addition: ${packageManager}`);
+            throw new Error(`Unsupported package manager: ${packageManager}`);
     }
-    const child = spawn(command, args, {
+    const child = (0, __rspack_external_node_child_process_27f17141.spawn)(command, args, {
         cwd: projectRoot,
         stdio: 'inherit'
     });
-    await once(child, 'exit');
+    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':
@@ -435,1449 +706,1585 @@ function getManualInstallCommand(dependencies, packageManager) {
             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)=>picocolors.cyan(d)).join(', ');
-    if (!autoInstall) {
-        const addDepsSelection = await prompts_confirm({
-            message: `Add required dependencies using ${picocolors.cyan(context.packageManager.name)}? (${depsString})`,
-            initialValue: true
-        });
-        if (handleCancel?.(addDepsSelection)) return {
-            installDepsConfirmed: false,
-            ranInstall: false
-        };
-        if (!addDepsSelection) return {
-            installDepsConfirmed: false,
-            ranInstall: false
+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);
     }
-    s.start(`Running ${picocolors.cyan(context.packageManager.name)} to add and install dependencies... (this might take a moment)`);
+    return {
+        installed,
+        missing
+    };
+});
+async function readFileForBackup(filePath) {
+    const fs = await import("node:fs/promises");
     try {
-        await addAndInstallDependenciesViaPM(context.projectRoot, dependenciesToAdd, context.packageManager.name);
-        s.stop(`✅ Dependencies installed: ${dependenciesToAdd.map((d)=>picocolors.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(picocolors.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 = getManualInstallCommand(dependenciesToAdd, context.packageManager.name);
-        logger.info(`Please try running '${pmCommand}' manually in ${picocolors.cyan(node_path.relative(context.cwd, context.projectRoot))}.`);
-        return {
-            installDepsConfirmed: true,
-            ranInstall: false
-        };
+        return await fs.readFile(filePath, 'utf-8');
+    } catch  {
+        return null;
     }
 }
-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 `${picocolors.bgRed(picocolors.black(' error '))} ${messageStr}${formattedArgs}`;
-        case 'warn':
-            return `${picocolors.bgYellow(picocolors.black(' warning '))} ${messageStr}${formattedArgs}`;
-        case 'info':
-            return `${picocolors.bgGreen(picocolors.black(' info '))} ${messageStr}${formattedArgs}`;
-        case 'debug':
-            return `${picocolors.bgBlack(picocolors.white(' debug '))} ${messageStr}${formattedArgs}`;
-        case 'success':
-            return `${picocolors.bgGreen(picocolors.white(' success '))} ${messageStr}${formattedArgs}`;
-        case 'failed':
-            return `${picocolors.bgRed(picocolors.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':
-            outro(formattedMessage);
-            break;
-        default:
-            prompts_log.message(formattedMessage);
+async function fileExists(filePath) {
+    const fs = await import("node:fs/promises");
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch  {
+        return false;
     }
-};
-const createCliLogger = (level)=>{
-    const baseLogger = createLogger({
-        level,
-        appName: 'c15t',
-        log: (logLevel, message, ...args)=>{
-            logMessage(logLevel, message, ...args);
+}
+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'
+            ]
         }
-    });
-    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;
-        note(messageStr, title, {
-            format: (line)=>line
+    ];
+    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
     };
-    extendedLogger.success = (message, ...args)=>{
-        logMessage('success', message, ...args);
+    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}`)
     };
-    extendedLogger.failed = (message, ...args)=>{
-        logMessage('failed', message, ...args);
-        process.exit(0);
-    };
-    extendedLogger.outro = (message)=>{
-        outro(message);
-    };
-    return extendedLogger;
-};
-function generateClientConfigContent(mode, backendURL, useEnvFile, logger) {
-    let configContent = '';
-    const validModes = [
-        'c15t',
-        'offline',
-        'custom'
-    ];
-    switch(mode){
-        case 'c15t':
-            configContent = `
-import {
-  type ConsentManagerOptions,
-  configureConsentManager,
-  createConsentManagerStore
-} from "c15t";
-
-export const consentManager = configureConsentManager({ mode: "c15t", backendURL: ${useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL' : `'${backendURL || 'https://your-instance.c15t.dev'}'`}, });
-export const store = createConsentManagerStore(consentManager, {
-  initialGdprTypes: ["necessary", "marketing"], // Optional: Specify which consent categories to show in the banner.
-  ignoreGeoLocation: true // Useful for development to always view the banner.
-});
-
-store.getState().setConsent("marketing", true); // set consent to marketing
-store.getState().showPopup; 
-`;
-            break;
-        case 'offline':
-            configContent = `
-import {
-  type ConsentManagerOptions,
-  configureConsentManager,
-  createConsentManagerStore
-} from "c15t";
-
-export const consentManager = configureConsentManager({ mode: "offline" });
-export const store = createConsentManagerStore(consentManager, {
-  initialGdprTypes: ["necessary", "marketing"], // Optional: Specify which consent categories to show in the banner.
-});
-
-store.getState().setConsent("marketing", true); // set consent to marketing
-store.getState().showPopup; // should show popup?
-      
-`;
-            break;
-        case 'custom':
-            configContent = `import {
-  type ConsentManagerOptions,
-  configureConsentManager,
-  createConsentManagerStore
-} from "c15t";
-
-export const consentManager = configureConsentManager({ mode: "custom", endpointHandlers: createCustomHandlers(), });
-export const store = createConsentManagerStore(consentManager, {
-  initialGdprTypes: ["necessary", "marketing"], // Optional: Specify which consent categories to show in the banner.
-  ignoreGeoLocation: true // Useful for development to always view the banner.
-});
-
-store.getState().setConsent("marketing", true); // set consent to marketing
-store.getState().showPopup; // should show popup?
-`;
-            break;
-        default:
-            logger?.failed(`Invalid mode: ${mode}. Valid modes are: ${validModes.join(', ')}`);
-    }
-    return configContent;
-}
-function getEnvVarName(pkg) {
-    return '@c15t/nextjs' === pkg ? 'NEXT_PUBLIC_C15T_URL' : 'PUBLIC_C15T_URL';
-}
-function generateEnvFileContent(backendURL, pkg) {
-    const envVarName = getEnvVarName(pkg);
-    return `\n${envVarName}=${backendURL}\n`;
-}
-function generateEnvExampleContent(pkg) {
-    const envVarName = getEnvVarName(pkg);
-    return `\n# c15t Configuration\n${envVarName}=https://your-instance.c15t.dev\n`;
-}
-function generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs) {
-    switch(mode){
-        case 'c15t':
-            if (proxyNextjs) return `{
-					mode: 'c15t',
-					backendURL: '/api/c15t',
-					consentCategories: ['necessary', 'marketing'], // Optional: Specify which consent categories to show in the banner. 
-					ignoreGeoLocation: true, // Useful for development to always view the banner.
-				}`;
-            if (useEnvFile) return `{
-					mode: 'c15t',
-					backendURL: process.env.NEXT_PUBLIC_C15T_URL!,
-					consentCategories: ['necessary', 'marketing'], // Optional: Specify which consent categories to show in the banner. 
-					ignoreGeoLocation: true, // Useful for development to always view the banner.
-				}`;
-            return `{
-				mode: 'c15t',
-				backendURL: '${backendURL || 'https://your-instance.c15t.dev'}',
-				consentCategories: ['necessary', 'marketing'], // Optional: Specify which consent categories to show in the banner. 
-        ignoreGeoLocation: true, // Useful for development to always view the banner.
-			}`;
-        case 'custom':
-            return `{
-				mode: 'custom',
-				endpointHandlers: createCustomHandlers(),
-			}`;
-        default:
-            return `{
-				mode: 'offline',
-				consentCategories: ['necessary', 'marketing'], // Optional: Specify which consent categories to show in the banner. 
-			}`;
-    }
-}
-function generateConsentManagerTemplate(optionsText) {
-    return `import type { ReactNode } from 'react';
-import {
-	ConsentManagerDialog,
-	ConsentManagerProvider,
-	CookieBanner,
-} from '@c15t/nextjs';
-// For client-only apps (non-SSR), you can use:
-// import { ConsentManagerProvider } from '@c15t/nextjs/client';
-import { ConsentManagerClient } from './consent-manager.client';
-
-/**
- * Server-side rendered consent management wrapper for Next.js App Router
- *
- * This component provides SSR-compatible consent management by separating
- * server-side configuration from client-side functionality. The server handles
- * initial setup and configuration, while client-side features (callbacks,
- * scripts) are delegated to the ConsentManagerClient component.
- *
- * @param props - Component properties
- * @param props.children - Child components to render within the consent manager context
- *
- * @returns The consent manager provider with banner, dialog, and client wrapper
- *
- * @remarks
- * This split architecture is necessary because certain options like callbacks
- * and scripts cannot be serialized during server-side rendering. For
- * client-only implementations, use \`<ConsentManagerProvider />\` from
- * \`@c15t/nextjs/client\`.
- *
- * @example
- * \`\`\`tsx
- * // In your root layout.tsx
- * import { ConsentManager } from './consent-manager';
- *
- * export default function RootLayout({ children }) {
- *   return (
- *     <html>
- *       <body>
- *         <ConsentManager>
- *           {children}
- *         </ConsentManager>
- *       </body>
- *     </html>
- *   );
- * }
- * \`\`\`
- */
-export function ConsentManager({ children }: { children: ReactNode }) {
-	return (
-		<ConsentManagerProvider
-			options={${optionsText}}
-		>
-			<CookieBanner />
-			<ConsentManagerDialog />
-			<ConsentManagerClient>{children}</ConsentManagerClient>
-		</ConsentManagerProvider>
-	);
-}
-`;
-}
-function generateConsentManagerClientTemplate() {
-    return `'use client';
-
-import type { ReactNode } from 'react';
-import { ClientSideOptionsProvider } from '@c15t/nextjs/client';
-
-/**
- * Client-side consent manager wrapper for handling scripts and callbacks
- *
- * This component is rendered on the client and provides the ability to:
- * - Load integration scripts (Google Tag Manager, Meta Pixel, TikTok Pixel, etc.)
- * - Handle client-side callbacks (onConsentSet, onError, onBannerFetched)
- * - Manage script lifecycle (onLoad, onDelete)
- *
- * @param props - Component properties
- * @param props.children - Child components to render within the client-side context
- *
- * @returns The client-side options provider with children
- *
- * @see https://c15t.com/docs/frameworks/next/callbacks
- * @see https://c15t.com/docs/frameworks/next/script-loader
- */
-export function ConsentManagerClient({
-	children,
-}: {
-	children: ReactNode;
-}) {
-	return (
-		<ClientSideOptionsProvider
-			// 📝 Add your integration scripts here
-			// Scripts are loaded when consent is given and removed when consent is revoked
-			scripts={[
-				// Example:
-				// googleTagManager({
-				//   id: 'GTM-XXXXXX',
-				//   script: {
-				//     onLoad: () => console.log('GTM loaded'),
-				//   },
-				// }),
-			]}
-			// 📝 Add your callbacks here
-			// Callbacks allow you to react to consent events
-			callbacks={{
-				// Example:
-				// onConsentSet(response) {
-				//   console.log('Consent updated:', response);
-				// },
-				// onError(error) {
-				//   console.error('Consent error:', error);
-				// },
-			}}
-		>
-			{children}
-		</ClientSideOptionsProvider>
-	);
-}
-`;
-}
-const HTML_TAG_REGEX = /<html[^>]*>([\s\S]*)<\/html>/;
-const BODY_TAG_REGEX = /<body[^>]*>([\s\S]*)<\/body>/;
-const BODY_OPENING_TAG_REGEX = /<body[^>]*>/;
-const HTML_CONTENT_REGEX = /([\s\S]*<\/html>)/;
-function findAppLayoutFile(project, projectRoot) {
-    const layoutPatterns = [
-        'app/layout.tsx',
-        'src/app/layout.tsx',
-        'app/layout.ts',
-        'src/app/layout.ts'
-    ];
-    for (const pattern of layoutPatterns){
-        const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
-        if (files.length > 0) return files[0];
-    }
-}
-function getAppDirectory(layoutFilePath) {
-    const normalizedPath = node_path.normalize(layoutFilePath);
-    const srcAppSegment = node_path.join('src', 'app');
-    if (normalizedPath.includes(srcAppSegment)) return node_path.join('src', 'app');
-    return 'app';
-}
-function computeRelativeModuleSpecifier(fromFilePath, toFilePath) {
-    const fromDir = node_path.dirname(fromFilePath);
-    let relativePath = node_path.relative(fromDir, toFilePath);
-    relativePath = relativePath.split(node_path.sep).join('/');
-    relativePath = relativePath.replace(/\.(tsx?|jsx?)$/, '');
-    if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
-    return relativePath;
-}
-function addConsentManagerImport(layoutFile, consentManagerFilePath) {
-    const layoutFilePath = layoutFile.getFilePath();
-    const moduleSpecifier = computeRelativeModuleSpecifier(layoutFilePath, consentManagerFilePath);
-    const existingImports = layoutFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>{
-        const existingSpec = importDecl.getModuleSpecifierValue();
-        return existingSpec === moduleSpecifier || existingSpec.endsWith('consent-manager') || existingSpec.endsWith('consent-manager.tsx');
-    });
-    if (!hasConsentManagerImport) layoutFile.addImportDeclaration({
-        namedImports: [
-            'ConsentManager'
-        ],
-        moduleSpecifier
-    });
-}
-function wrapAppJsxContent(originalJsx) {
-    const hasHtmlTag = originalJsx.includes('<html') || originalJsx.includes('</html>');
-    const hasBodyTag = originalJsx.includes('<body') || originalJsx.includes('</body>');
-    const consentWrapper = (content)=>`
-		<ConsentManager>
-			${content}
-		</ConsentManager>
-	`;
-    if (hasHtmlTag) {
-        const htmlMatch = originalJsx.match(HTML_TAG_REGEX);
-        const htmlContent = htmlMatch?.[1] || '';
-        if (!htmlContent) return consentWrapper(originalJsx);
-        const bodyMatch = htmlContent.match(BODY_TAG_REGEX);
-        if (!bodyMatch) return originalJsx.replace(HTML_CONTENT_REGEX, `<html>${consentWrapper('$1')}</html>`);
-        const bodyContent = bodyMatch[1] || '';
-        const bodyOpeningTag = originalJsx.match(BODY_OPENING_TAG_REGEX)?.[0] || '<body>';
-        return originalJsx.replace(BODY_TAG_REGEX, `${bodyOpeningTag}${consentWrapper(bodyContent)}</body>`);
-    }
-    if (hasBodyTag) {
-        const bodyMatch = originalJsx.match(BODY_TAG_REGEX);
-        const bodyContent = bodyMatch?.[1] || '';
-        if (!bodyContent) return consentWrapper(originalJsx);
-        const bodyOpeningTag = originalJsx.match(BODY_OPENING_TAG_REGEX)?.[0] || '<body>';
-        return originalJsx.replace(BODY_TAG_REGEX, `${bodyOpeningTag}${consentWrapper(bodyContent)}</body>`);
-    }
-    return consentWrapper(originalJsx);
-}
-async function createConsentManagerComponents(projectRoot, appDir, optionsText) {
-    const appDirPath = node_path.join(projectRoot, appDir);
-    const consentManagerContent = generateConsentManagerTemplate(optionsText);
-    const consentManagerClientContent = generateConsentManagerClientTemplate();
-    const consentManagerPath = node_path.join(appDirPath, 'consent-manager.tsx');
-    const consentManagerClientPath = node_path.join(appDirPath, 'consent-manager.client.tsx');
-    await Promise.all([
-        promises.writeFile(consentManagerPath, consentManagerContent, 'utf-8'),
-        promises.writeFile(consentManagerClientPath, consentManagerClientContent, 'utf-8')
-    ]);
-    return {
-        consentManager: consentManagerPath,
-        consentManagerClient: consentManagerClientPath
-    };
-}
-async function updateAppLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs }) {
-    const project = new Project();
-    const layoutFile = findAppLayoutFile(project, projectRoot);
-    if (!layoutFile) return {
-        updated: false,
-        filePath: null,
-        alreadyModified: false
-    };
-    const layoutFilePath = layoutFile.getFilePath();
-    const appDir = getAppDirectory(layoutFilePath);
-    const existingImports = layoutFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>'./consent-manager' === importDecl.getModuleSpecifierValue() || './consent-manager.tsx' === importDecl.getModuleSpecifierValue());
-    if (hasConsentManagerImport) return {
-        updated: false,
-        filePath: layoutFilePath,
-        alreadyModified: true
-    };
-    const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs);
-    const componentFiles = await createConsentManagerComponents(projectRoot, appDir, optionsText);
-    addConsentManagerImport(layoutFile, componentFiles.consentManager);
-    const returnStatement = layoutFile.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
-    if (!returnStatement) return {
-        updated: false,
-        filePath: layoutFilePath,
-        alreadyModified: false
-    };
-    const expression = returnStatement.getExpression();
-    if (!expression) return {
-        updated: false,
-        filePath: layoutFilePath,
-        alreadyModified: false
-    };
-    const originalJsx = expression.getText();
-    const newJsx = wrapAppJsxContent(originalJsx);
-    returnStatement.replaceWithText(`return ${newJsx}`);
-    await layoutFile.save();
-    return {
-        updated: true,
-        filePath: layoutFilePath,
-        alreadyModified: false,
-        componentFiles
-    };
-}
-function components_generateConsentManagerTemplate(optionsText) {
-    return `import type { ReactNode } from 'react';
-import {
-	ConsentManagerDialog,
-	ConsentManagerProvider,
-	CookieBanner,
-  type InitialDataPromise
-} from '@c15t/nextjs/pages';
-// For client-only apps (non-SSR), you can use:
-// import { ConsentManagerProvider } from '@c15t/nextjs/client';
-
-/**
- * Consent management wrapper for Next.js Pages Router
- *
- * This component wraps your app with consent management functionality,
- * including the cookie banner, consent dialog, and provider.
- *
- * @param props - Component properties
- * @param props.children - Child components to render within the consent manager context
- * @param props.initialData - Initial consent data from server-side props (optional)
- *
- * @returns The consent manager provider with banner and dialog
- *
- * @remarks
- * To get initial server-side data on other pages, use:
- * \`\`\`tsx
- * import { withInitialC15TData } from '@c15t/nextjs/pages';
- *
- * export const getServerSideProps = withInitialC15TData('/api/c15t');
- * \`\`\`
- *
- * @example
- * \`\`\`tsx
- * // In your pages/_app.tsx
- * import { ConsentManager } from '../components/consent-manager';
- *
- * export default function MyApp({ Component, pageProps }) {
- *   return (
- *     <ConsentManager initialData={pageProps.initialC15TData}>
- *       <Component {...pageProps} />
- *     </ConsentManager>
- *   );
- * }
- * \`\`\`
- */
-export function ConsentManager({
-	children,
-	initialData,
-}: {
-	children: ReactNode;
-	initialData?: InitialDataPromise;
-}) {
-	return (
-		<ConsentManagerProvider
-			initialData={initialData}
-			options={${optionsText}}
-		>
-			<CookieBanner />
-			<ConsentManagerDialog />
-			{children}
-		</ConsentManagerProvider>
-	);
-}
-`;
-}
-function findPagesAppFile(project, projectRoot) {
-    const appPatterns = [
-        'pages/_app.tsx',
-        'pages/_app.ts',
-        'src/pages/_app.tsx',
-        'src/pages/_app.ts'
-    ];
-    for (const pattern of appPatterns){
-        const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
-        if (files.length > 0) return files[0];
-    }
-}
-function getPagesDirectory(appFilePath) {
-    const normalizedPath = node_path.normalize(appFilePath);
-    const srcPagesSegment = node_path.join('src', 'pages');
-    if (normalizedPath.includes(srcPagesSegment)) return node_path.join('src', 'pages');
-    return 'pages';
-}
-function layout_computeRelativeModuleSpecifier(fromFilePath, toFilePath) {
-    const fromDir = node_path.dirname(fromFilePath);
-    let relativePath = node_path.relative(fromDir, toFilePath);
-    relativePath = relativePath.split(node_path.sep).join('/');
-    relativePath = relativePath.replace(/\.(tsx?|jsx?)$/, '');
-    if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
-    return relativePath;
-}
-function layout_addConsentManagerImport(appFile, consentManagerFilePath) {
-    const appFilePath = appFile.getFilePath();
-    const moduleSpecifier = layout_computeRelativeModuleSpecifier(appFilePath, consentManagerFilePath);
-    const existingImports = appFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>{
-        const existingSpec = importDecl.getModuleSpecifierValue();
-        return existingSpec === moduleSpecifier || existingSpec.endsWith('consent-manager') || existingSpec.endsWith('consent-manager.tsx');
-    });
-    if (!hasConsentManagerImport) appFile.addImportDeclaration({
-        namedImports: [
-            'ConsentManager'
-        ],
-        moduleSpecifier
-    });
-}
-function wrapPagesJsxContent(originalJsx) {
-    const trimmedJsx = originalJsx.trim();
-    const hasParentheses = trimmedJsx.startsWith('(') && trimmedJsx.endsWith(')');
-    const cleanJsx = hasParentheses ? trimmedJsx.slice(1, -1).trim() : originalJsx;
-    const wrappedContent = `
-		<ConsentManager initialData={pageProps.initialC15TData}>
-			${cleanJsx}
-		</ConsentManager>
-	`;
-    return `(${wrappedContent})`;
-}
-async function createConsentManagerComponent(projectRoot, pagesDir, optionsText) {
-    let componentsDir;
-    componentsDir = pagesDir.includes('src') ? node_path.join('src', 'components') : 'components';
-    const componentsDirPath = node_path.join(projectRoot, componentsDir);
-    await promises.mkdir(componentsDirPath, {
-        recursive: true
-    });
-    const consentManagerContent = components_generateConsentManagerTemplate(optionsText);
-    const consentManagerPath = node_path.join(componentsDirPath, 'consent-manager.tsx');
-    await promises.writeFile(consentManagerPath, consentManagerContent, 'utf-8');
-    return {
-        consentManager: consentManagerPath
-    };
-}
-function addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs) {
-    const existingComments = appFile.getLeadingCommentRanges();
-    let urlExample;
-    urlExample = proxyNextjs ? "'/api/c15t'" : useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL!' : `'${backendURL || 'https://your-instance.c15t.dev'}'`;
-    const serverSideComment = `/**
- * Note: To get the initial server-side data on other pages, add this to each page:
- *
- * import { withInitialC15TData } from '@c15t/nextjs/pages';
- *
- * export const getServerSideProps = withInitialC15TData(${urlExample});
- *
- * This will automatically pass initialC15TData to pageProps.initialC15TData
- */`;
-    const hasServerSideComment = existingComments.some((comment)=>comment.getText().includes('withInitialC15TData'));
-    if (!hasServerSideComment) appFile.insertText(0, `${serverSideComment}\n\n`);
-}
-function updateAppComponentTyping(appFile) {
-    const exportAssignment = appFile.getExportAssignment(()=>true);
-    if (!exportAssignment) return;
-    const declaration = exportAssignment.getExpression();
-    if (!declaration) return;
-    const text = declaration.getText();
-    if (text.includes('pageProps') && !text.includes('AppProps')) {
-        const hasAppPropsImport = appFile.getImportDeclarations().some((importDecl)=>'next/app' === importDecl.getModuleSpecifierValue() && importDecl.getNamedImports().some((namedImport)=>'AppProps' === namedImport.getName()));
-        if (!hasAppPropsImport) appFile.addImportDeclaration({
-            namedImports: [
-                'AppProps'
-            ],
-            moduleSpecifier: 'next/app'
+    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
         });
-    }
-}
-async function updatePagesLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs }) {
-    const project = new Project();
-    const appFile = findPagesAppFile(project, projectRoot);
-    if (!appFile) return {
-        updated: false,
-        filePath: null,
-        alreadyModified: false
-    };
-    const appFilePath = appFile.getFilePath();
-    const pagesDir = getPagesDirectory(appFilePath);
-    const existingImports = appFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>{
-        const specifier = importDecl.getModuleSpecifierValue();
-        return specifier.endsWith('/consent-manager') || specifier.endsWith('/consent-manager.tsx') || './consent-manager' === specifier || './consent-manager.tsx' === specifier;
-    });
-    if (hasConsentManagerImport) return {
-        updated: false,
-        filePath: appFilePath,
-        alreadyModified: true
-    };
-    const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs);
-    const componentFiles = await createConsentManagerComponent(projectRoot, pagesDir, optionsText);
-    layout_addConsentManagerImport(appFile, componentFiles.consentManager);
-    updateAppComponentTyping(appFile);
-    addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs);
-    const returnStatement = appFile.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
-    if (!returnStatement) return {
-        updated: false,
-        filePath: appFilePath,
-        alreadyModified: false
-    };
-    const expression = returnStatement.getExpression();
-    if (!expression) return {
-        updated: false,
-        filePath: appFilePath,
-        alreadyModified: false
-    };
-    const originalJsx = expression.getText();
-    const newJsx = wrapPagesJsxContent(originalJsx);
-    returnStatement.replaceWithText(`return ${newJsx}`);
-    await appFile.save();
-    return {
-        updated: true,
-        filePath: appFilePath,
-        alreadyModified: false,
-        componentFiles
-    };
-}
-function detectNextJsStructure(projectRoot) {
-    const project = new Project();
-    const appLayoutPatterns = [
-        'app/layout.tsx',
-        'src/app/layout.tsx',
-        'app/layout.ts',
-        'src/app/layout.ts'
-    ];
-    for (const pattern of appLayoutPatterns){
-        const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
-        if (files.length > 0) return 'app';
-    }
-    const pagesAppPatterns = [
-        'pages/_app.tsx',
-        'pages/_app.ts',
-        'src/pages/_app.tsx',
-        'src/pages/_app.ts'
-    ];
-    for (const pattern of pagesAppPatterns){
-        const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
-        if (files.length > 0) return 'pages';
-    }
-    return null;
-}
-async function updateNextLayout(options) {
-    const structureType = detectNextJsStructure(options.projectRoot);
-    if (!structureType) return {
-        updated: false,
-        filePath: null,
-        alreadyModified: false,
-        structureType: null
-    };
-    let result;
-    result = 'app' === structureType ? await updateAppLayout(options) : await updatePagesLayout(options);
-    return {
-        ...result,
-        structureType
-    };
-}
-function react_components_generateConsentManagerTemplate(optionsText) {
-    return `import type { ReactNode } from 'react';
-import {
-	ConsentManagerDialog,
-	ConsentManagerProvider,
-	CookieBanner,
-} from '@c15t/react';
-
-/**
- * Consent management wrapper for React
- *
- * This component wraps your app with consent management functionality,
- * including the cookie banner, consent dialog, and provider.
- *
- * @param props - Component properties
- * @param props.children - Child components to render within the consent manager context
- *
- * @returns The consent manager provider with banner and dialog
- *
- * @example
- * \`\`\`tsx
- * // In your App.tsx
- * import { ConsentManager } from './consent-manager';
- *
- * export default function App() {
- *   return (
- *     <ConsentManager>
- *       <YourApp />
- *     </ConsentManager>
- *   );
- * }
- * \`\`\`
- */
-export function ConsentManager({ children }: { children: ReactNode }) {
-	return (
-		<ConsentManagerProvider
-			options={${optionsText}}
-		>
-			<CookieBanner />
-			<ConsentManagerDialog />
-			{children}
-		</ConsentManagerProvider>
-	);
-}
-`;
-}
-function templates_layout_computeRelativeModuleSpecifier(fromFilePath, toFilePath) {
-    const fromDir = node_path.dirname(fromFilePath);
-    let relativePath = node_path.relative(fromDir, toFilePath);
-    relativePath = relativePath.split(node_path.sep).join('/');
-    relativePath = relativePath.replace(/\.(tsx?|jsx?)$/, '');
-    if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
-    return relativePath;
-}
-function templates_layout_addConsentManagerImport(layoutFile, consentManagerFilePath) {
-    const layoutFilePath = layoutFile.getFilePath();
-    const moduleSpecifier = templates_layout_computeRelativeModuleSpecifier(layoutFilePath, consentManagerFilePath);
-    const existingImports = layoutFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>{
-        const existingSpec = importDecl.getModuleSpecifierValue();
-        return existingSpec === moduleSpecifier || existingSpec.endsWith('consent-manager') || existingSpec.endsWith('consent-manager.tsx');
-    });
-    if (!hasConsentManagerImport) layoutFile.addImportDeclaration({
-        namedImports: [
-            'ConsentManager'
-        ],
-        moduleSpecifier
-    });
-}
-function getSourceDirectory(layoutFilePath) {
-    const normalizedPath = node_path.normalize(layoutFilePath);
-    const segments = normalizedPath.split(node_path.sep);
-    if (segments.includes('src')) return 'src';
-    return '';
-}
-function updateGenericReactJsx(layoutFile) {
-    const functionDeclarations = layoutFile.getFunctions();
-    const variableDeclarations = layoutFile.getVariableDeclarations();
-    for (const func of functionDeclarations){
-        const returnStatement = func.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
-        if (returnStatement) return wrapReturnStatementWithConsentManager(returnStatement);
-    }
-    for (const varDecl of variableDeclarations){
-        const initializer = varDecl.getInitializer();
-        if (initializer) {
-            const returnStatement = initializer.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
-            if (returnStatement) return wrapReturnStatementWithConsentManager(returnStatement);
+        if (generateResult.configPath) {
+            result.configPath = generateResult.configPath;
+            if (!filesModified.some((f)=>f.path === generateResult.configPath)) filesCreated.push(generateResult.configPath);
         }
-    }
-    return false;
-}
-function wrapReturnStatementWithConsentManager(returnStatement) {
-    const expression = returnStatement.getExpression();
-    if (!expression) return false;
-    const originalJsx = expression.getText();
-    const newJsx = `(
-		<ConsentManager>
-			${originalJsx}
-		</ConsentManager>
-	)`;
-    returnStatement.replaceWithText(`return ${newJsx}`);
-    return true;
-}
-async function layout_createConsentManagerComponent(projectRoot, sourceDir, optionsText) {
-    const targetDir = sourceDir ? node_path.join(projectRoot, sourceDir) : projectRoot;
-    const consentManagerContent = react_components_generateConsentManagerTemplate(optionsText);
-    const consentManagerPath = node_path.join(targetDir, 'consent-manager.tsx');
-    await promises.writeFile(consentManagerPath, consentManagerContent, 'utf-8');
-    return {
-        consentManager: consentManagerPath
-    };
-}
-async function updateGenericReactLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs }) {
-    const layoutPatterns = [
-        'app.tsx',
-        'App.tsx',
-        'app.jsx',
-        'App.jsx',
-        'src/app.tsx',
-        'src/App.tsx',
-        'src/app.jsx',
-        'src/App.jsx',
-        'src/app/app.tsx',
-        'src/app/App.tsx',
-        'src/app/app.jsx',
-        'src/app/App.jsx'
-    ];
-    const project = new Project();
-    let layoutFile;
-    for (const pattern of layoutPatterns)try {
-        const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
-        if (files.length > 0) {
-            layoutFile = files[0];
-            break;
+        if (generateResult.layoutPath) result.layoutPath = generateResult.layoutPath;
+        if (generateResult.nextConfigPath) {
+            result.nextConfigPath = generateResult.nextConfigPath;
+            if (generateResult.nextConfigCreated) filesCreated.push(generateResult.nextConfigPath);
         }
-    } catch  {}
-    if (!layoutFile) return {
-        updated: false,
-        filePath: null,
-        alreadyModified: false
-    };
-    const layoutFilePath = layoutFile.getFilePath();
-    const sourceDir = getSourceDirectory(layoutFilePath);
-    const existingImports = layoutFile.getImportDeclarations();
-    const hasConsentManagerImport = existingImports.some((importDecl)=>'./consent-manager' === importDecl.getModuleSpecifierValue() || './consent-manager.tsx' === importDecl.getModuleSpecifierValue());
-    if (hasConsentManagerImport) return {
-        updated: false,
-        filePath: layoutFilePath,
-        alreadyModified: true
-    };
-    try {
-        const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs);
-        const componentFiles = await layout_createConsentManagerComponent(projectRoot, sourceDir, optionsText);
-        templates_layout_addConsentManagerImport(layoutFile, componentFiles.consentManager);
-        const updated = updateGenericReactJsx(layoutFile);
-        if (updated) {
-            await layoutFile.save();
-            return {
-                updated: true,
-                filePath: layoutFilePath,
-                alreadyModified: false,
-                componentFiles
-            };
+        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);
         }
-        return {
-            updated: false,
-            filePath: layoutFilePath,
-            alreadyModified: false
-        };
+        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) {
-        throw new Error(`Failed to update generic React layout: ${error instanceof Error ? error.message : String(error)}`);
+        result.filesCreated = filesCreated;
+        result.filesModified = filesModified;
+        throw error;
     }
-}
-async function updateReactLayout(options) {
-    if ('@c15t/nextjs' === options.pkg) {
-        const nextResult = await updateNextLayout(options);
-        if (nextResult.structureType) return {
-            updated: nextResult.updated,
-            filePath: nextResult.filePath,
-            alreadyModified: nextResult.alreadyModified,
-            componentFiles: nextResult.componentFiles
-        };
+});
+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)}`);
     }
-    return updateGenericReactLayout(options);
-}
-async function updateNextConfig({ projectRoot, backendURL, useEnvFile }) {
-    const project = new Project();
-    const configFile = findNextConfigFile(project, projectRoot);
-    if (!configFile) {
-        const newConfigPath = `${projectRoot}/next.config.ts`;
-        const newConfig = createNewNextConfig(backendURL, useEnvFile);
-        const newConfigFile = project.createSourceFile(newConfigPath, newConfig);
-        await newConfigFile.save();
-        return {
-            updated: true,
-            filePath: newConfigPath,
-            alreadyModified: false,
-            created: true
-        };
+    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)}`);
     }
-    if (hasC15tRewriteRule(configFile)) return {
-        updated: false,
-        filePath: configFile.getFilePath(),
-        alreadyModified: true,
-        created: false
-    };
-    const updated = await updateExistingConfig(configFile, backendURL, useEnvFile);
-    if (updated) await configFile.save();
     return {
-        updated,
-        filePath: configFile.getFilePath(),
-        alreadyModified: false,
-        created: false
+        success: 0 === errors.length,
+        errors
     };
-}
-function findNextConfigFile(project, projectRoot) {
-    const configPatterns = [
-        'next.config.ts',
-        'next.config.js',
-        'next.config.mjs'
-    ];
-    for (const pattern of configPatterns){
-        const configPath = `${projectRoot}/${pattern}`;
-        try {
-            const files = project.addSourceFilesAtPaths(configPath);
-            if (files.length > 0) return files[0];
-        } catch  {}
-    }
-}
-function hasC15tRewriteRule(configFile) {
-    const text = configFile.getFullText();
-    return text.includes('/api/c15t/') || text.includes("'/api/c15t/:path*'");
-}
-function generateRewriteDestination(backendURL, useEnvFile) {
-    if (useEnvFile) return {
-        destination: '${process.env.NEXT_PUBLIC_C15T_URL}/:path*',
-        isTemplateLiteral: true
-    };
-    return {
-        destination: `${backendURL || 'https://your-instance.c15t.dev'}/:path*`,
-        isTemplateLiteral: false
-    };
-}
-function createNewNextConfig(backendURL, useEnvFile) {
-    const { destination, isTemplateLiteral } = generateRewriteDestination(backendURL, useEnvFile);
-    const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
-    return `import type { NextConfig } from 'next';
-
-const config: NextConfig = {
-	async rewrites() {
-		return [
-			{
-				source: '/api/c15t/:path*',
-				destination: ${destinationValue},
-			},
-		];
-	},
-};
-
-export default config;
-`;
-}
-function createRewriteRule(destination, isTemplateLiteral) {
-    const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
-    return `{
-		source: '/api/c15t/:path*',
-		destination: ${destinationValue},
-	}`;
-}
-function updateExistingConfig(configFile, backendURL, useEnvFile) {
-    const { destination, isTemplateLiteral } = generateRewriteDestination(backendURL, useEnvFile);
-    const configObject = findConfigObject(configFile);
-    if (!configObject) return false;
-    const rewritesProperty = configObject.getProperty('rewrites');
-    if (rewritesProperty && Node.isMethodDeclaration(rewritesProperty)) return updateExistingRewrites(rewritesProperty, destination, isTemplateLiteral);
-    if (rewritesProperty && Node.isPropertyAssignment(rewritesProperty)) return updatePropertyAssignmentRewrites(rewritesProperty, destination, isTemplateLiteral);
-    return addNewRewritesMethod(configObject, destination, isTemplateLiteral);
-}
-function findConfigObject(configFile) {
-    return findConfigFromExportDefault(configFile) || findConfigFromVariableDeclarations(configFile);
-}
-function findConfigFromExportDefault(configFile) {
-    const exportDefault = configFile.getDefaultExportSymbol();
-    if (!exportDefault) return;
-    const declarations = exportDefault.getDeclarations();
-    for (const declaration of declarations)if (Node.isExportAssignment(declaration)) {
-        const result = findConfigFromExpression(declaration.getExpression(), configFile);
-        if (result) return result;
-    }
-}
-function findConfigFromExpression(expression, configFile) {
-    if (Node.isCallExpression(expression)) return findConfigFromCallExpression(expression, configFile);
-    if (Node.isObjectLiteralExpression(expression)) return expression;
-    if (Node.isIdentifier(expression)) return findConfigFromIdentifier(expression.getText(), configFile);
-}
-function findConfigFromCallExpression(expression, configFile) {
-    const args = expression.getArguments();
-    if (0 === args.length) return;
-    const firstArg = args[0];
-    if (Node.isCallExpression(firstArg)) {
-        const innerArgs = firstArg.getArguments();
-        if (innerArgs.length > 0 && Node.isIdentifier(innerArgs[0])) return findConfigFromIdentifier(innerArgs[0].getText(), configFile);
-    }
-}
-function findConfigFromIdentifier(identifierText, configFile) {
-    const configVar = configFile.getVariableDeclaration(identifierText);
-    const initializer = configVar?.getInitializer();
-    return initializer && Node.isObjectLiteralExpression(initializer) ? initializer : void 0;
-}
-function findConfigFromVariableDeclarations(configFile) {
-    const variableDeclarations = configFile.getVariableDeclarations();
-    for (const varDecl of variableDeclarations){
-        const typeNode = varDecl.getTypeNode();
-        if (typeNode?.getText().includes('NextConfig')) {
-            const initializer = varDecl.getInitializer();
-            if (Node.isObjectLiteralExpression(initializer)) return initializer;
-        }
-    }
-}
-function updateExistingRewrites(rewritesMethod, destination, isTemplateLiteral) {
-    const body = rewritesMethod.getBody();
-    if (!Node.isBlock(body)) return false;
-    const returnStatement = body.getStatements().find((stmt)=>Node.isReturnStatement(stmt));
-    if (!returnStatement || !Node.isReturnStatement(returnStatement)) return false;
-    const expression = returnStatement.getExpression();
-    if (!expression || !Node.isArrayLiteralExpression(expression)) return false;
-    const newRewrite = createRewriteRule(destination, isTemplateLiteral);
-    const elements = expression.getElements();
-    if (elements.length > 0) expression.insertElement(0, newRewrite);
-    else expression.addElement(newRewrite);
-    return true;
-}
-function updatePropertyAssignmentRewrites(rewritesProperty, destination, isTemplateLiteral) {
-    const initializer = rewritesProperty.getInitializer();
-    if (Node.isArrayLiteralExpression(initializer)) {
-        const newRewrite = createRewriteRule(destination, isTemplateLiteral);
-        initializer.insertElement(0, newRewrite);
+});
+async function preflight_fileExists(filePath) {
+    try {
+        const fs = await import("node:fs/promises");
+        await fs.access(filePath);
         return true;
+    } catch  {
+        return false;
     }
-    return false;
-}
-function addNewRewritesMethod(configObject, destination, isTemplateLiteral) {
-    const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
-    const rewritesMethod = `async rewrites() {
-		return [
-			{
-				source: '/api/c15t/:path*',
-				destination: ${destinationValue},
-			},
-		];
-	}`;
-    configObject.addProperty(rewritesMethod);
-    return true;
-}
-async function handleReactLayout(options) {
-    const { projectRoot, mode, backendURL, useEnvFile, proxyNextjs, pkg, spinner, cwd } = options;
-    spinner.start('Updating layout file...');
-    const layoutResult = await updateReactLayout({
-        projectRoot,
-        mode,
-        backendURL,
-        useEnvFile,
-        proxyNextjs,
-        pkg
-    });
-    const spinnerMessage = ()=>{
-        if (layoutResult.alreadyModified) return {
-            message: 'ConsentManager is already imported. Skipped layout file update.',
-            type: 'info'
-        };
-        if (layoutResult.updated) {
-            const typedResult = layoutResult;
-            if (typedResult.componentFiles) {
-                const relativeConsentManager = node_path.relative(cwd, typedResult.componentFiles.consentManager);
-                const relativeLayout = node_path.relative(cwd, layoutResult.filePath || '');
-                if (typedResult.componentFiles.consentManagerClient) {
-                    const relativeConsentManagerClient = node_path.relative(cwd, typedResult.componentFiles.consentManagerClient);
-                    return {
-                        message: `Layout setup complete!\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManager)}\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManagerClient)}\n  ${picocolors.green('✓')} Updated: ${picocolors.cyan(relativeLayout)}`,
-                        type: 'info'
-                    };
-                }
-                return {
-                    message: `Layout setup complete!\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManager)}\n  ${picocolors.green('✓')} Updated: ${picocolors.cyan(relativeLayout)}`,
-                    type: 'info'
-                };
-            }
-            return {
-                message: `Layout file updated: ${layoutResult.filePath}`,
-                type: 'info'
-            };
-        }
-        return {
-            message: 'Layout file not updated.',
-            type: 'error'
-        };
-    };
-    const { message, type } = spinnerMessage();
-    spinner.stop(formatLogMessage(type, message));
-    return {
-        layoutUpdated: layoutResult.updated,
-        layoutPath: layoutResult.filePath
-    };
 }
-async function handleNextConfig(options) {
-    const { projectRoot, backendURL, useEnvFile, spinner } = options;
-    spinner.start('Updating Next.js config...');
-    const configResult = await updateNextConfig({
-        projectRoot,
-        backendURL,
-        useEnvFile
-    });
-    const spinnerMessage = ()=>{
-        if (configResult.alreadyModified) return {
-            message: 'Next.js config already has c15t rewrite rule. Skipped config update.',
-            type: 'info'
-        };
-        if (configResult.updated && configResult.created) return {
-            message: `Next.js config created: ${configResult.filePath}`,
-            type: 'info'
+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'
         };
-        if (configResult.updated) return {
-            message: `Next.js config updated: ${configResult.filePath}`,
-            type: 'info'
+        return {
+            name: 'Git',
+            status: 'pass',
+            message: 'Git repository detected'
         };
+    } catch  {
         return {
-            message: 'Next.js config not updated.',
-            type: 'error'
+            name: 'Git',
+            status: 'warn',
+            message: 'Could not check git status'
         };
-    };
-    const { message, type } = spinnerMessage();
-    spinner.stop(formatLogMessage(type, message));
+    }
+}
+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 {
-        nextConfigUpdated: configResult.updated,
-        nextConfigPath: configResult.filePath,
-        nextConfigCreated: configResult.created
+        passed: !hasFailures,
+        checks,
+        projectRoot,
+        framework: {
+            name: framework.framework,
+            version: framework.frameworkVersion,
+            pkg: framework.pkg,
+            hasReact: framework.hasReact,
+            reactVersion: framework.reactVersion,
+            tailwindVersion: framework.tailwindVersion
+        },
+        packageManager
     };
 }
-async function handleEnvFiles(options) {
-    const { projectRoot, backendURL, pkg, spinner, cwd } = options;
-    const envPath = node_path.join(projectRoot, '.env.local');
-    const envExamplePath = node_path.join(projectRoot, '.env.example');
-    spinner.start('Creating/updating environment files...');
-    const envContent = generateEnvFileContent(backendURL, pkg);
-    const envExampleContent = generateEnvExampleContent(pkg);
-    const envVarName = getEnvVarName(pkg);
-    try {
-        const [envExists, envExampleExists] = await Promise.all([
-            promises.access(envPath).then(()=>true).catch(()=>false),
-            promises.access(envExamplePath).then(()=>true).catch(()=>false)
-        ]);
-        if (envExists) {
-            const currentEnvContent = await promises.readFile(envPath, 'utf-8');
-            if (!currentEnvContent.includes(envVarName)) await promises.appendFile(envPath, envContent);
-        } else await promises.writeFile(envPath, envContent);
-        if (envExampleExists) {
-            const currentExampleContent = await promises.readFile(envExamplePath, 'utf-8');
-            if (!currentExampleContent.includes(envVarName)) await promises.appendFile(envExamplePath, envExampleContent);
-        } else await promises.writeFile(envExamplePath, envExampleContent);
-        spinner.stop(formatLogMessage('info', `Environment files added/updated successfully: ${picocolors.cyan(node_path.relative(cwd, envPath))} and ${picocolors.cyan(node_path.relative(cwd, envExamplePath))}`));
-    } catch (error) {
-        spinner.stop(formatLogMessage('error', `Error processing environment files: ${error instanceof Error ? error.message : String(error)}`));
-        throw error;
+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 ' ';
     }
 }
-async function generateFiles({ context, mode, spinner, useEnvFile, proxyNextjs, backendURL }) {
-    const result = {
-        layoutUpdated: false
-    };
-    const { projectRoot, framework: { pkg } } = context;
-    if ('@c15t/nextjs' === pkg || '@c15t/react' === pkg) {
-        const layoutResult = await handleReactLayout({
-            projectRoot,
-            mode,
-            backendURL,
-            useEnvFile,
-            proxyNextjs,
-            pkg,
-            spinner,
-            cwd: context.cwd
-        });
-        result.layoutUpdated = layoutResult.layoutUpdated;
-        result.layoutPath = layoutResult.layoutPath;
-    }
-    if ('@c15t/nextjs' === pkg && proxyNextjs && 'c15t' === mode) {
-        const configResult = await handleNextConfig({
-            projectRoot,
-            backendURL,
-            useEnvFile,
-            spinner
+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'
         });
-        result.nextConfigUpdated = configResult.nextConfigUpdated;
-        result.nextConfigPath = configResult.nextConfigPath;
-        result.nextConfigCreated = configResult.nextConfigCreated;
-    }
-    if ('c15t' === pkg) {
-        spinner.start('Generating client configuration file...');
-        result.configContent = generateClientConfigContent(mode, backendURL, useEnvFile);
-        result.configPath = node_path.join(projectRoot, 'c15t.config.ts');
-        spinner.stop(formatLogMessage('info', `Client configuration file generated: ${result.configContent}`));
     }
-    if (useEnvFile && backendURL) await handleEnvFiles({
-        projectRoot,
-        backendURL,
-        pkg,
-        spinner,
-        cwd: context.cwd
-    });
-    return result;
+    return enableDevTools;
 }
-async function getScriptsToAdd({ context, handleCancel }) {
-    context.logger.info("@c15t/scripts has various prebuilt scripts for you to use. Learn more: https://c15t.com/docs/integrations");
-    const addScriptsSelection = await prompts_confirm({
-        message: "Do you want to add @c15t/scripts to your project?",
-        initialValue: true
-    });
-    if (handleCancel?.(addScriptsSelection)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: "scripts_addition"
-    });
-    return addScriptsSelection;
-}
-async function getSharedFrontendOptions({ backendURL, context, handleCancel }) {
-    let useEnvFile = false;
-    let proxyNextjs;
-    if (!backendURL) return {
-        proxyNextjs: void 0,
-        useEnvFile: void 0,
-        dependenciesToAdd: []
-    };
-    const useEnvFileSelection = await prompts_confirm({
-        message: 'Store the backendURL in a .env file? (Recommended, URL is public)',
+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
     });
-    if (handleCancel?.(useEnvFileSelection)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'self_hosted_env_file_setup'
-    });
-    useEnvFile = useEnvFileSelection;
-    if ('@c15t/nextjs' === context.framework.pkg) {
-        context.logger.info('Learn more about Next.js Rewrites: https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites');
-        const proxyNextjsSelection = await prompts_confirm({
-            message: 'Proxy requests to your instance with Next.js Rewrites? (Recommended)',
-            initialValue: true
-        });
-        if (handleCancel?.(proxyNextjsSelection)) context.error.handleCancel('Setup cancelled.', {
+    const cancelled = handleCancel?.(enableSSR) ?? prompts_.isCancel(enableSSR);
+    if (cancelled) {
+        if (onCancel) onCancel();
+        context.error.handleCancel('Setup cancelled.', {
             command: 'onboarding',
-            stage: 'self_hosted_proxy_nextjs_setup'
+            stage: 'ssr_option'
         });
-        proxyNextjs = proxyNextjsSelection;
     }
-    const addScriptsSelection = await getScriptsToAdd({
-        context,
-        handleCancel
+    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'
+            }
+        ]
     });
-    const dependenciesToAdd = [
-        context.framework.pkg
-    ];
-    if (addScriptsSelection) dependenciesToAdd.push("@c15t/scripts");
+    if (isCancel(result)) throw new PromptCancelledError('mode_selection');
     return {
-        proxyNextjs,
-        useEnvFile,
-        dependenciesToAdd
+        mode: result
     };
-}
-async function handleAccountCreation(context, handleCancel) {
-    const { logger } = context;
-    const needsAccount = await prompts_confirm({
+});
+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 (handleCancel?.(needsAccount)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'c15t_account_creation'
-    });
-    if (!needsAccount) return;
-    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({
+    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 (handleCancel?.(shouldOpen)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'c15t_browser_open'
-    });
+    if (isCancel(shouldOpen)) throw new PromptCancelledError('browser_open');
+    let browserOpened = false;
     if (shouldOpen) try {
-        await open_0('https://consent.io/dashboard/register?ref=cli');
-        const enterPressed = await prompts_text({
+        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 (handleCancel?.(enterPressed)) context.error.handleCancel('Setup cancelled.', {
-            command: 'onboarding',
-            stage: 'c15t_url_input'
-        });
-    } catch  {
-        logger.warn('Failed to open browser automatically. Please visit https://consent.io/dashboard/register manually.');
+        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.');
     }
-}
-async function getBackendURL(context, initialBackendURL, handleCancel) {
-    const backendURLSelection = await prompts_text({
-        message: 'Enter your consent.io instance URL:',
-        placeholder: 'https://your-instance.c15t.dev',
-        initialValue: initialBackendURL,
+    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 (!url.hostname.endsWith('.c15t.dev')) return 'Please enter a valid *.c15t.dev URL';
+                if (isC15tMode && !url.hostname.endsWith('.c15t.dev')) return 'Please enter a valid *.c15t.dev URL';
             } catch  {
                 return 'Please enter a valid URL';
             }
         }
     });
-    if (handleCancel?.(backendURLSelection)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'c15t_url_validation'
+    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 (!backendURLSelection || '' === backendURLSelection) context.error.handleCancel('A valid consent.io URL is required', {
-        command: 'onboarding',
-        stage: 'c15t_url_validation'
+    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 backendURLSelection;
-}
-async function setupC15tMode({ context, spinner, initialBackendURL, handleCancel }) {
-    await handleAccountCreation(context, handleCancel);
-    const backendURL = await getBackendURL(context, initialBackendURL, handleCancel);
-    const { useEnvFile, proxyNextjs, dependenciesToAdd } = await getSharedFrontendOptions({
-        backendURL: backendURL,
-        context,
-        handleCancel
+    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
     });
-    await generateFiles({
-        context,
-        mode: 'c15t',
-        backendURL,
-        spinner,
-        useEnvFile,
-        proxyNextjs
+    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
     });
-    const { ranInstall, installDepsConfirmed } = await installDependencies({
-        context,
-        dependenciesToAdd,
-        handleCancel
+    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 {
-        backendURL,
-        usingEnvFile: useEnvFile ?? false,
-        proxyNextjs,
-        installDepsConfirmed,
-        ranInstall
+        opened: false
     };
+});
+function preflightPassed({ context }) {
+    return context.preflightPassed;
 }
-async function setupCustomMode({ context, spinner }) {
-    const { logger, cwd, framework: { pkg } } = context;
-    if (!pkg) throw new Error('Error detecting framework');
-    const result = await generateFiles({
-        context,
-        mode: 'custom',
-        spinner
-    });
-    logger.info(`Remember to implement custom endpoint handlers ${result.configPath ? `(see ${picocolors.cyan(node_path.relative(cwd, result.configPath))})` : ''}`);
-    const { ranInstall, installDepsConfirmed } = await installDependencies({
-        context,
-        dependenciesToAdd: [
-            context.framework.pkg
+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'
     });
-    return {
-        clientConfigContent: result.configContent ?? '',
-        installDepsConfirmed,
-        ranInstall
-    };
+    await (0, __rspack_external_node_events_0a6aefe7.once)(child, 'exit');
 }
-async function setupOfflineMode({ context, spinner, handleCancel }) {
-    const addScriptsSelection = await getScriptsToAdd({
-        context,
-        handleCancel
-    });
-    const result = await generateFiles({
-        context,
-        mode: 'offline',
-        spinner
-    });
-    const dependenciesToAdd = [
-        context.framework.pkg
-    ];
-    if (addScriptsSelection) dependenciesToAdd.push("@c15t/scripts");
-    const { ranInstall, installDepsConfirmed } = await installDependencies({
-        context,
-        dependenciesToAdd
-    });
-    return {
-        clientConfigContent: result.configContent ?? '',
-        installDepsConfirmed,
-        ranInstall
+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',
@@ -1981,7 +2388,7 @@ const CONFIG_BUILDERS = {
 };
 async function pathExists(filePath) {
     try {
-        await promises.access(filePath);
+        await promises_["default"].access(filePath);
         return true;
     } catch  {
         return false;
@@ -2072,7 +2479,7 @@ function buildMongoPrelude(connection) {
 }
 function buildFileContent(adapter, provider, dbConfig, connection) {
     const adapterPath = 'mongoAdapter' === adapter ? 'mongo' : adapter.replace('Adapter', '');
-    const importAdapter = `import { ${adapter} } from '@c15t/backend/v2/db/adapters/${adapterPath}';`;
+    const importAdapter = `import { ${adapter} } from '@c15t/backend/db/adapters/${adapterPath}';`;
     let extras = {
         imports: '',
         prelude: ''
@@ -2085,7 +2492,7 @@ function buildFileContent(adapter, provider, dbConfig, 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/v2';
+    return `import { defineConfig } from '@c15t/backend';
 ${importAdapter}
 ${extras.imports ? `${extras.imports}\n` : ''}
 ${extras.prelude ? `${extras.prelude}\n` : ''}
@@ -2095,14 +2502,14 @@ export default defineConfig({
 `;
 }
 async function promptSelectAdapter() {
-    const selection = await prompts_select({
+    const selection = await prompts_.select({
         message: 'Select database adapter:',
         options: Object.keys(ADAPTER_LABELS).map((key)=>({
                 value: key,
                 label: ADAPTER_LABELS[key]
             }))
     });
-    if (isCancel(selection)) throw new Cancelled('adapter_select');
+    if (prompts_.isCancel(selection)) throw new Cancelled('adapter_select');
     return selection;
 }
 async function promptSelectProvider(adapter) {
@@ -2112,14 +2519,14 @@ async function promptSelectProvider(adapter) {
         const [first] = providers;
         return first.value;
     }
-    const selection = await prompts_select({
+    const selection = await prompts_.select({
         message: 'Select database provider:',
         options: providers.map((opt)=>({
                 value: opt.value,
                 label: opt.label
             }))
     });
-    if (isCancel(selection)) throw new Cancelled('provider_select');
+    if (prompts_.isCancel(selection)) throw new Cancelled('provider_select');
     return selection;
 }
 async function promptConnection(adapter, provider) {
@@ -2127,42 +2534,42 @@ async function promptConnection(adapter, provider) {
         useEnv: true
     };
     if ('sqlite' === provider) {
-        const sqliteFile = await prompts_text({
+        const sqliteFile = await prompts_.text({
             message: 'SQLite file path:',
             initialValue: './db.sqlite'
         });
-        if (isCancel(sqliteFile)) throw new Cancelled('sqlite_path');
+        if (prompts_.isCancel(sqliteFile)) throw new Cancelled('sqlite_path');
         connection.sqliteFile = String(sqliteFile);
         return connection;
     }
-    const useEnv = await prompts_confirm({
+    const useEnv = await prompts_.confirm({
         message: 'Store connection string in an environment variable?',
         initialValue: true
     });
-    if (isCancel(useEnv)) throw new Cancelled('use_env_confirm');
+    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({
+        const envVarName = await prompts_.text({
             message: 'Env var name for connection string:',
             initialValue: defaultVar
         });
-        if (isCancel(envVarName)) throw new Cancelled('env_var_name');
+        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({
+    const connectionString = await prompts_.text({
         message: 'Connection string:',
         placeholder
     });
-    if (isCancel(connectionString)) throw new Cancelled('connection_string');
+    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 = node_path.join(cwd, 'c15t-backend.config.ts');
+    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 {
@@ -2191,8 +2598,8 @@ async function ensureBackendConfig(context) {
         else if ('mongoAdapter' === adapter) dependencies.push('mongodb');
         const dbConfig = buildDatabaseConfig(adapter, provider, connection);
         const fileContent = buildFileContent(adapter, String(provider), dbConfig, connection);
-        await promises.writeFile(targetPath, fileContent, 'utf8');
-        context.logger.success(`Created ${node_path.relative(cwd, targetPath)}`);
+        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,
@@ -2211,26 +2618,26 @@ async function handleMigrationResult(context, result) {
     telemetry.trackEvent(TelemetryEventName.MIGRATION_PLANNED, {
         success: true
     });
-    const saveSQL = await prompts_confirm({
+    const saveSQL = await prompts_.confirm({
         message: 'Save SQL to file?',
         initialValue: true
     });
-    if (isCancel(saveSQL)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
+    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 = join(process.cwd(), filename);
-        await writeFile(filepath, sql, 'utf-8');
+        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({
+    const execute = await prompts_.confirm({
         message: 'Execute this migration?',
         initialValue: false
     });
-    if (isCancel(execute)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
+    if (prompts_.isCancel(execute)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
         execute: false
     });
     await result.execute();
@@ -2241,11 +2648,11 @@ async function handleMigrationResult(context, result) {
 }
 async function handleORMResult(context, result) {
     const { logger, telemetry, cwd } = context;
-    const filePath = node_path.join(cwd, result.path);
-    await promises.mkdir(node_path.dirname(filePath), {
+    const filePath = external_node_path_["default"].join(cwd, result.path);
+    await promises_["default"].mkdir(external_node_path_["default"].dirname(filePath), {
         recursive: true
     });
-    await promises.writeFile(filePath, result.code);
+    await promises_["default"].writeFile(filePath, result.code);
     logger.info(`Migration file created at ${filePath}`);
     telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
         success: true,
@@ -2255,14 +2662,14 @@ async function handleORMResult(context, result) {
 async function readConfigAndGetDb(context, absoluteConfigPath) {
     const { logger } = context;
     logger.info(`Loading backend config from ${absoluteConfigPath}`);
-    const resolvedPath = node_path.resolve(absoluteConfigPath);
+    const resolvedPath = external_node_path_["default"].resolve(absoluteConfigPath);
     try {
-        await promises.access(resolvedPath);
+        await promises_["default"].access(resolvedPath);
     } catch  {
         throw new Error(`Backend config not found at: ${resolvedPath}`);
     }
     try {
-        const { config } = await loadConfig({
+        const { config } = await (0, __rspack_external_c12.loadConfig)({
             configFile: absoluteConfigPath,
             jitiOptions: {
                 extensions: [
@@ -2279,8 +2686,9 @@ async function readConfigAndGetDb(context, absoluteConfigPath) {
             }
         });
         logger.debug('Imported Config');
+        if (!config || 'object' != typeof config || !('adapter' in config)) throw new Error('Invalid backend config: missing required "adapter" property');
         return {
-            db: DB.client(config.adapter)
+            db: __rspack_external__c15t_backend_db_schema_e7c5e6a0.DB.client(config.adapter)
         };
     } catch (error) {
         logger.error('Failed to load backend config', error);
@@ -2301,285 +2709,13 @@ async function migrate(context) {
     });
     const { db } = await readConfigAndGetDb(context, path);
     logger.info('Loaded c15t-backend.config.ts');
-    const result = await migrator({
+    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);
 }
-async function setupSelfHostedMode({ context, spinner, handleCancel }) {
-    const dependenciesToAdd = new Set([
-        context.framework.pkg,
-        '@c15t/backend'
-    ]);
-    const targetPath = node_path.join(context.cwd, 'c15t-backend.config.ts');
-    let createBackendConfig = false;
-    if (!await pathExists(targetPath)) {
-        const config = await ensureBackendConfig(context);
-        createBackendConfig = true;
-        for (const dep of config?.dependencies ?? [])dependenciesToAdd.add(dep);
-    }
-    const backendURL = await prompts_text({
-        message: 'Enter the backend URL:',
-        initialValue: 'http://localhost:3000'
-    });
-    if (handleCancel?.(backendURL)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'self_hosted_backend_url_setup'
-    });
-    const { useEnvFile, proxyNextjs, dependenciesToAdd: sharedDependenciesToAdd } = await getSharedFrontendOptions({
-        backendURL: backendURL,
-        context,
-        handleCancel
-    });
-    for (const dep of sharedDependenciesToAdd)dependenciesToAdd.add(dep);
-    await generateFiles({
-        context,
-        mode: 'c15t',
-        backendURL: backendURL,
-        spinner,
-        useEnvFile,
-        proxyNextjs
-    });
-    const { ranInstall, installDepsConfirmed } = await installDependencies({
-        context,
-        dependenciesToAdd: Array.from(dependenciesToAdd),
-        handleCancel
-    });
-    const runMigrations = await prompts_confirm({
-        message: 'Would you like to run migrations?',
-        initialValue: true
-    });
-    if (handleCancel?.(runMigrations)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'self_hosted_run_migrations_setup'
-    });
-    if (runMigrations) await migrate(context);
-    return {
-        backendURL: backendURL,
-        usingEnvFile: useEnvFile ?? false,
-        proxyNextjs,
-        createBackendConfig: createBackendConfig,
-        installDepsConfirmed,
-        ranInstall,
-        runMigrations: runMigrations
-    };
-}
-const WINDOWS_PATH_SEPARATOR_REGEX = /\\/g;
-const FILE_EXTENSION_REGEX = /\.(ts|js|tsx|jsx)$/;
-async function generate(context, mode) {
-    const { logger, telemetry } = context;
-    logger.debug('Starting generate command...');
-    logger.debug(`Mode: ${mode}`);
-    const handleCancel = (value)=>{
-        if (isCancel(value)) {
-            telemetry.trackEvent(TelemetryEventName.ONBOARDING_EXITED, {
-                reason: 'user_cancelled',
-                command: 'onboarding',
-                stage: 'setup'
-            });
-            context.error.handleCancel('Configuration cancelled.', {
-                command: 'onboarding',
-                stage: 'setup'
-            });
-        }
-        return false;
-    };
-    try {
-        logger.info('Starting onboarding process...');
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_STARTED, {});
-        telemetry.flushSync();
-        await performOnboarding(context, handleCancel, mode);
-        logger.success('🚀 Setup completed successfully!');
-    } catch (error) {
-        if (!isCancel(error)) telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-        });
-    }
-}
-async function performOnboarding(context, handleCancel, mode) {
-    const { telemetry, logger, packageManager } = context;
-    const projectRoot = await detectProjectRoot(context.cwd, logger);
-    const { pkg } = await detectFramework(projectRoot, logger);
-    if (!pkg) throw new Error('Error detecting framework');
-    let selectedMode = mode ?? null;
-    logger.debug(`Selected mode: ${selectedMode}`);
-    if (!selectedMode) selectedMode = await handleStorageModeSelection(context, handleCancel);
-    if (!selectedMode) return;
-    const sharedOptions = {
-        context,
-        spinner: prompts_spinner(),
-        handleCancel
-    };
-    let installDepsConfirmed = false;
-    let ranInstall = false;
-    const dependenciesToAdd = [];
-    switch(selectedMode){
-        case 'c15t':
-            {
-                const c15tResult = await setupC15tMode(sharedOptions);
-                installDepsConfirmed = c15tResult.installDepsConfirmed;
-                ranInstall = c15tResult.ranInstall;
-                dependenciesToAdd.push(context.framework.pkg);
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_C15T_MODE_CONFIGURED, {
-                    usingEnvFile: c15tResult.usingEnvFile,
-                    proxyNextjs: c15tResult.proxyNextjs
-                });
-                break;
-            }
-        case 'offline':
-            {
-                const offlineResult = await setupOfflineMode({
-                    context,
-                    spinner: prompts_spinner()
-                });
-                installDepsConfirmed = offlineResult.installDepsConfirmed;
-                ranInstall = offlineResult.ranInstall;
-                dependenciesToAdd.push(context.framework.pkg);
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_OFFLINE_MODE_CONFIGURED, {});
-                break;
-            }
-        case 'self-hosted':
-            {
-                const selfHostedResult = await setupSelfHostedMode({
-                    context,
-                    spinner: prompts_spinner(),
-                    handleCancel
-                });
-                installDepsConfirmed = selfHostedResult.installDepsConfirmed;
-                ranInstall = selfHostedResult.ranInstall;
-                dependenciesToAdd.push(context.framework.pkg);
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_SELF_HOSTED_CONFIGURED, {});
-                break;
-            }
-        default:
-            {
-                const customResult = await setupCustomMode({
-                    context,
-                    spinner: prompts_spinner()
-                });
-                installDepsConfirmed = customResult.installDepsConfirmed;
-                ranInstall = customResult.ranInstall;
-                dependenciesToAdd.push(context.framework.pkg);
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_CUSTOM_MODE_CONFIGURED, {});
-                break;
-            }
-    }
-    await displayNextSteps({
-        context,
-        projectRoot,
-        storageMode: selectedMode,
-        installDepsConfirmed,
-        ranInstall,
-        dependenciesToAdd,
-        packageManager
-    });
-    await handleGitHubStar(context);
-    telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
-        success: true,
-        selectedMode,
-        installDependencies: ranInstall
-    });
-}
-async function handleStorageModeSelection(context, handleCancel) {
-    const { telemetry } = context;
-    const storageModeSelection = await prompts_select({
-        message: 'How would you like to store consent decisions?',
-        initialValue: '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 (handleCancel(storageModeSelection)) return null;
-    const storageMode = storageModeSelection;
-    telemetry.trackEvent(TelemetryEventName.ONBOARDING_STORAGE_MODE_SELECTED, {
-        storageMode
-    });
-    return storageMode;
-}
-async function displayNextSteps(options) {
-    const { context, projectRoot, storageMode, installDepsConfirmed, ranInstall, dependenciesToAdd, packageManager } = options;
-    const { logger, cwd } = context;
-    const { log } = prompts_namespaceObject;
-    const configPath = node_path.join(projectRoot, 'c15t.config.ts');
-    const relativeConfigPath = node_path.relative(cwd, configPath);
-    const importPath = `./${relativeConfigPath.replace(WINDOWS_PATH_SEPARATOR_REGEX, '/').replace(FILE_EXTENSION_REGEX, '')}`;
-    const importStatement = picocolors.cyan(`import { c15tConfig } from '${importPath}';`);
-    switch(storageMode){
-        case 'c15t':
-            break;
-        case 'offline':
-            break;
-        case 'self-hosted':
-            log.step('Setup your backend with the c15t docs:');
-            logger.info('https://c15t.com/docs/self-host/v2');
-            break;
-        case 'custom':
-            {
-                log.step('Configuration Complete! Next Steps:');
-                const steps = `1. Implement your custom endpoint handlers (referenced in ${picocolors.cyan(relativeConfigPath)}).\n      2. Import and use configuration in your app: ${importStatement}`;
-                logger.info(steps);
-                break;
-            }
-    }
-    if (installDepsConfirmed && !ranInstall) logger.info(`  - ${picocolors.yellow('Dependency installation failed.')} Please check errors and install manually.`);
-    else if (!ranInstall && dependenciesToAdd.length > 0) {
-        const pmCommand = getManualInstallCommand(dependenciesToAdd, packageManager.name);
-        logger.warn(`  - Run ${picocolors.cyan(pmCommand)} to install required dependencies.`);
-    }
-}
-async function handleGitHubStar(context) {
-    const { logger, telemetry } = context;
-    logger.note(`${picocolors.bold('✨ Setup complete!')} Your c15t configuration is ready to use. \n
-
-We're building c15t as an ${picocolors.bold('open source')} project to make consent management more accessible.
-If you find this useful, we'd really appreciate a GitHub star - it helps others discover the project!`, '🎉 Thanks for using c15t');
-    const shouldOpenGitHub = await prompts_confirm({
-        message: 'Would you like to star c15t on GitHub now?',
-        initialValue: true
-    });
-    if (isCancel(shouldOpenGitHub)) {
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_GITHUB_STAR, {
-            action: 'cancelled'
-        });
-        return context.error.handleCancel('GitHub star prompt cancelled. Exiting onboarding.', {
-            command: 'onboarding',
-            stage: 'github_star'
-        });
-    }
-    telemetry.trackEvent(TelemetryEventName.ONBOARDING_GITHUB_STAR, {
-        action: shouldOpenGitHub ? 'opened_browser' : 'declined'
-    });
-    if (shouldOpenGitHub) try {
-        note('Your support helps us continue improving c15t.\nThank you for being part of our community!', '⭐ Star Us on GitHub');
-        await open_0('https://github.com/c15t/c15t');
-        logger.success('GitHub repository opened. Thank you for your support!');
-    } catch (error) {
-        logger.debug('Failed to open browser:', error);
-        logger.info(`You can star us later by visiting: ${picocolors.cyan('https://github.com/c15t/c15t')}`);
-    }
-}
 const subcommands = [
     {
         name: 'generate',
@@ -2632,14 +2768,14 @@ async function selfHost(context) {
         label: 'Exit',
         hint: 'Return to main menu'
     });
-    const selectedSubcommandName = await prompts_select({
-        message: formatLogMessage('info', 'Which self-host command would you like to run?'),
+    const selectedSubcommandName = await prompts_.select({
+        message: (0, utils_logger.$e)('info', 'Which self-host command would you like to run?'),
         options: promptOptions
     });
-    if (isCancel(selectedSubcommandName) || 'exit' === selectedSubcommandName) {
+    if (prompts_.isCancel(selectedSubcommandName) || 'exit' === selectedSubcommandName) {
         logger.debug('Interactive selection cancelled or exit chosen.');
         telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-            action: isCancel(selectedSubcommandName) ? 'cancelled' : 'exit',
+            action: prompts_.isCancel(selectedSubcommandName) ? 'cancelled' : 'exit',
             context: 'self-host'
         });
         error.handleCancel('Operation cancelled.', {
@@ -2667,12 +2803,12 @@ async function selfHost(context) {
 }
 async function displayIntro(context, version) {
     const { logger } = context;
-    logger.info(`${picocolors.bold('Welcome!')} Let's get you set up.`);
+    logger.info(`${external_picocolors_["default"].bold('Welcome!')} Let's get you set up.`);
     logger.message('');
     let figletText = 'c15t';
     try {
         figletText = await new Promise((resolve)=>{
-            figlet.text('c15t', {
+            __rspack_external_figlet["default"].text('c15t', {
                 font: 'Nancyj-Improved',
                 horizontalLayout: 'default',
                 verticalLayout: 'default',
@@ -2712,6 +2848,7 @@ async function displayIntro(context, version) {
     });
     logger.message(coloredLines.join('\n'));
 }
+var constants = __webpack_require__("./src/constants.ts");
 function createErrorHandlers(context) {
     const { logger, telemetry } = context;
     return {
@@ -2719,7 +2856,7 @@ function createErrorHandlers(context) {
             logger.error(message, error);
             if (error instanceof Error) logger.error(error.message);
             else logger.error(String(error));
-            logger.failed(`${picocolors.red('Operation failed unexpectedly.')}`);
+            logger.failed(`${external_picocolors_["default"].red('Operation failed unexpectedly.')}`);
             process.exit(1);
         },
         handleCancel: (message = 'Operation cancelled.', context)=>{
@@ -2739,10 +2876,10 @@ function createFileSystem(context) {
     return {
         getPackageInfo: ()=>{
             logger.debug('Reading package.json');
-            const packageJsonPath = node_path.join(cwd, 'package.json');
+            const packageJsonPath = external_node_path_["default"].join(cwd, 'package.json');
             logger.debug(`package.json path: ${packageJsonPath}`);
             try {
-                const packageInfo = fs_extra.readJSONSync(packageJsonPath);
+                const packageInfo = __rspack_external_fs_extra_ce68a66b["default"].readJSONSync(packageJsonPath);
                 logger.debug('Successfully read package.json');
                 return {
                     name: packageInfo?.name || 'unknown',
@@ -2759,6 +2896,99 @@ function createFileSystem(context) {
         }
     };
 }
+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',
@@ -2777,7 +3007,7 @@ async function getPackageManagerVersion(pm) {
 async function detectPackageManager(projectRoot, logger) {
     try {
         logger?.debug('Detecting package manager');
-        const pm = await detect({
+        const pm = await (0, __rspack_external_package_manager_detector_detect_94d6a9ae.detect)({
             cwd: projectRoot
         });
         if (!pm) throw new Error('No package manager detected');
@@ -2790,7 +3020,7 @@ async function detectPackageManager(projectRoot, logger) {
     } catch (error) {
         logger?.error(`Error detecting package manager: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const selectedPackageManager = await prompts_select({
+    const selectedPackageManager = await prompts_.select({
         message: 'Please select your package manager:',
         options: [
             {
@@ -2812,7 +3042,7 @@ async function detectPackageManager(projectRoot, logger) {
         ],
         initialValue: 'npm'
     });
-    if (isCancel(selectedPackageManager)) {
+    if (prompts_.isCancel(selectedPackageManager)) {
         logger?.debug('Package manager selection cancelled by user');
         logger?.failed('Package manager selection cancelled. Exiting.');
         process.exit(0);
@@ -2907,7 +3137,7 @@ function parseCliArgs(rawArgs, commands) {
                     if (nextArg && !nextArg.startsWith('-')) {
                         parsedFlags[primaryName] = nextArg;
                         i++;
-                    } else prompts_log.warn(formatLogMessage('warn', `Flag ${arg} expects a value, but none was found or the next item is a flag.`));
+                    } 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;
@@ -2928,11 +3158,11 @@ function createUserInteraction(context) {
     return {
         confirm: async (message, initialValue)=>{
             logger.debug(`Confirm action: "${message}", Initial: ${initialValue}`);
-            const confirmed = await prompts_confirm({
+            const confirmed = await prompts_.confirm({
                 message,
                 initialValue
             });
-            if (isCancel(confirmed)) {
+            if (prompts_.isCancel(confirmed)) {
                 error.handleCancel();
                 return false;
             }
@@ -2945,10 +3175,10 @@ 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 (validLogLevels.includes(levelArg)) desiredLogLevel = levelArg;
+    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 = createCliLogger(desiredLogLevel);
+    const logger = (0, utils_logger.xw)(desiredLogLevel);
     logger.debug(`Logger initialized with level: ${desiredLogLevel}`);
     const baseContext = {
         logger,
@@ -3018,8 +3248,8 @@ const src_commands = [
         description: 'Open our GitHub repository to give us a star.',
         action: async (context)=>{
             const { logger } = context;
-            logger.note(`We're building c15t as an ${picocolors.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 open_0('https://github.com/c15t/c15t');
+            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!');
         }
     },
@@ -3030,7 +3260,7 @@ const src_commands = [
         description: 'Open the c15t documentation in your browser.',
         action: async (context)=>{
             const { logger } = context;
-            await open_0('https://c15t.com/docs?ref=cli');
+            await (0, __rspack_external_open["default"])(`${constants.tl.DOCS}?ref=cli`);
             logger.success('Documentation opened in your browser.');
         }
     }
@@ -3044,8 +3274,8 @@ async function main() {
     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 ${picocolors.cyan('--no-telemetry')}
-flag or set ${picocolors.cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.`, `${formatLogMessage('info', 'Telemetry Notice')}`);
+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,
@@ -3118,14 +3348,14 @@ flag or set ${picocolors.cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.
                 label: 'exit',
                 hint: 'Close the CLI'
             });
-            const selectedCommandName = await prompts_select({
-                message: formatLogMessage('info', 'Which command would you like to run?'),
+            const selectedCommandName = await prompts_.select({
+                message: (0, utils_logger.$e)('info', 'Which command would you like to run?'),
                 options: promptOptions
             });
-            if (isCancel(selectedCommandName) || 'exit' === selectedCommandName) {
+            if (prompts_.isCancel(selectedCommandName) || 'exit' === selectedCommandName) {
                 logger.debug('Interactive selection cancelled or exit chosen.');
                 telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-                    action: isCancel(selectedCommandName) ? 'cancelled' : 'exit'
+                    action: prompts_.isCancel(selectedCommandName) ? 'cancelled' : 'exit'
                 });
                 context.error.handleCancel('Operation cancelled.', {
                     command: 'interactive_menu',