@c15t/cli 2.0.0-rc.4 → 2.0.0-rc.5

package/dist/index.mjs

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import * as __rspack_external__clack_prompts_3cae1695 from "@clack/prompts";
 import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+import * as __rspack_external_node_os_74b4b876 from "node:os";
 import * as __rspack_external_node_path_c5b9b54f from "node:path";
 import * as __rspack_external_picocolors from "picocolors";
+import * as __rspack_external_ts_morph_07c7ce60 from "ts-morph";
 import "dotenv/config";
 import * as __rspack_external_open from "open";
 import * as __rspack_external_xstate from "xstate";
 import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
-import * as __rspack_external_node_os_74b4b876 from "node:os";
 import * as __rspack_external_posthog_node_1b07bdf4 from "posthog-node";
 import * as __rspack_external_node_child_process_27f17141 from "node:child_process";
 import * as __rspack_external_node_events_0a6aefe7 from "node:events";
@@ -19,21 +20,127 @@ 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/auth/config-store.ts" (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            getAccessToken: ()=>getAccessToken,
+            Ex: ()=>storeTokens,
+            IM: ()=>getAuthState,
+            _g: ()=>setSelectedInstanceId
+        });
+        var promises_ = __webpack_require__("node:fs/promises");
+        var external_node_os_ = __webpack_require__("node:os");
+        var external_node_path_ = __webpack_require__("node:path");
+        var constants = __webpack_require__("./src/constants.ts");
+        function getConfigDir() {
+            return external_node_path_["default"].join(external_node_os_["default"].homedir(), constants.R7.CONFIG_DIR);
+        }
+        function getConfigPath() {
+            return external_node_path_["default"].join(getConfigDir(), constants.R7.CONFIG_FILE);
+        }
+        async function ensureConfigDir() {
+            const configDir = getConfigDir();
+            await promises_["default"].mkdir(configDir, {
+                recursive: true
+            });
+        }
+        async function loadConfig() {
+            try {
+                const configPath = getConfigPath();
+                const content = await promises_["default"].readFile(configPath, 'utf-8');
+                const config = JSON.parse(content);
+                if (!config.accessToken) return null;
+                return config;
+            } catch (error) {
+                return null;
+            }
+        }
+        async function saveConfig(config) {
+            await ensureConfigDir();
+            const configPath = getConfigPath();
+            const content = JSON.stringify(config, null, 2);
+            await promises_["default"].writeFile(configPath, content, {
+                mode: 384
+            });
+        }
+        async function updateConfig(updates) {
+            const existing = await loadConfig();
+            if (!existing) return null;
+            const updated = {
+                ...existing,
+                ...updates
+            };
+            await saveConfig(updated);
+            return updated;
+        }
+        function isTokenExpired(config) {
+            if (!config.expiresAt) return false;
+            const buffer = 300000;
+            return Date.now() > config.expiresAt - buffer;
+        }
+        async function getAuthState() {
+            const config = await loadConfig();
+            if (!config) return {
+                isLoggedIn: false,
+                config: null,
+                isExpired: false
+            };
+            return {
+                isLoggedIn: true,
+                config,
+                isExpired: isTokenExpired(config)
+            };
+        }
+        async function getAccessToken() {
+            const config = await loadConfig();
+            if (!config || isTokenExpired(config)) return null;
+            return config.accessToken;
+        }
+        async function setSelectedInstanceId(instanceId) {
+            await updateConfig({
+                selectedInstanceId: instanceId
+            });
+        }
+        async function storeTokens(accessToken, options) {
+            const config = {
+                accessToken,
+                refreshToken: options?.refreshToken,
+                expiresAt: options?.expiresIn ? Date.now() + 1000 * options.expiresIn : void 0,
+                email: options?.email,
+                lastLogin: Date.now()
+            };
+            const existing = await loadConfig();
+            if (existing?.selectedInstanceId) config.selectedInstanceId = existing.selectedInstanceId;
+            await saveConfig(config);
+        }
+    },
     "./src/constants.ts" (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             $V: ()=>STORAGE_MODES,
+            Aw: ()=>CLI_INFO,
             Lk: ()=>LAYOUT_PATTERNS,
             QL: ()=>REGEX,
+            R7: ()=>PATHS,
             Vj: ()=>PAGES_APP_PATTERNS,
+            fT: ()=>TIMEOUTS,
+            h3: ()=>ENV_VARS,
             tl: ()=>URLS
         });
         const URLS = {
             CONSENT_IO: 'https://consent.io',
-            DOCS: 'https://c15t.dev/docs',
+            DOCS: 'https://v2.c15t.com/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'
+            DISCORD: 'https://v2.c15t.com/discord',
+            API_DOCS: 'https://v2.c15t.com/docs/api',
+            CLI_DOCS: 'https://v2.c15t.com/docs/cli',
+            CHANGELOG: 'https://v2.c15t.com/changelog'
+        };
+        const PATHS = {
+            CONFIG_DIR: '.c15t',
+            CONFIG_FILE: 'config.json',
+            PROJECT_CONFIG: 'c15t.config.ts',
+            PROJECT_CONFIG_JS: 'c15t.config.js',
+            ENV_FILE: '.env',
+            ENV_LOCAL: '.env.local'
         };
         const REGEX = {
             URL: /^https?:\/\/.+/,
@@ -42,7 +149,28 @@ var __webpack_modules__ = {
             SEMVER: /^\d+\.\d+\.\d+(-[\w.]+)?$/,
             PACKAGE_NAME: /^(@[\w-]+\/)?[\w-]+$/
         };
+        const CLI_INFO = {
+            NAME: 'c15t',
+            BIN: 'c15t',
+            CONTROL_PLANE_CLIENT_NAME: 'c15t-cli',
+            VERSION: '2.0.0'
+        };
+        const TIMEOUTS = {
+            DEVICE_FLOW_POLL_INTERVAL: 5,
+            DEVICE_FLOW_EXPIRY: 900,
+            HTTP_REQUEST: 10000,
+            CONTROL_PLANE_CONNECTION: 30000
+        };
+        const ENV_VARS = {
+            V2: 'V2',
+            TELEMETRY_DISABLED: 'C15T_TELEMETRY_DISABLED',
+            CONSENT_URL: 'CONSENT_URL',
+            BACKEND_URL: 'C15T_URL',
+            API_KEY: 'C15T_API_KEY',
+            DEBUG: 'C15T_DEBUG'
+        };
         const STORAGE_MODES = {
+            HOSTED: 'hosted',
             C15T: 'c15t',
             OFFLINE: 'offline',
             SELF_HOSTED: 'self-hosted',
@@ -175,113 +303,1925 @@ var __webpack_modules__ = {
             return extendedLogger;
         };
     },
-    "@clack/prompts" (module) {
-        module.exports = __rspack_external__clack_prompts_3cae1695;
+    "@clack/prompts" (module) {
+        module.exports = __rspack_external__clack_prompts_3cae1695;
+    },
+    "node:fs/promises" (module) {
+        module.exports = __rspack_external_node_fs_promises_153e37e0;
+    },
+    "node:os" (module) {
+        module.exports = __rspack_external_node_os_74b4b876;
+    },
+    "node:path" (module) {
+        module.exports = __rspack_external_node_path_c5b9b54f;
+    },
+    picocolors (module) {
+        module.exports = __rspack_external_picocolors;
+    },
+    "ts-morph" (module) {
+        module.exports = __rspack_external_ts_morph_07c7ce60;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.f = {};
+    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + chunkId + ".mjs";
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    var installedChunks = {
+        410: 0
+    };
+    var installChunk = (data)=>{
+        var __rspack_esm_ids = data.__rspack_esm_ids;
+        var __webpack_modules__ = data.__webpack_modules__;
+        var __rspack_esm_runtime = data.__rspack_esm_runtime;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+        for(; i < __rspack_esm_ids.length; i++){
+            chunkId = __rspack_esm_ids[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[__rspack_esm_ids[i]] = 0;
+        }
+    };
+    __webpack_require__.f.j = function(chunkId, promises) {
+        var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
+        if (0 !== installedChunkData) if (installedChunkData) promises.push(installedChunkData[1]);
+        else {
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e)=>{
+                if (0 !== installedChunks[chunkId]) installedChunks[chunkId] = void 0;
+                throw e;
+            });
+            var promise = Promise.race([
+                promise,
+                new Promise((resolve)=>{
+                    installedChunkData = installedChunks[chunkId] = [
+                        resolve
+                    ];
+                })
+            ]);
+            promises.push(installedChunkData[1] = promise);
+        }
+    };
+})();
+var prompts_ = __webpack_require__("@clack/prompts");
+var external_picocolors_ = __webpack_require__("picocolors");
+function showHelpMenu(context, version, commands, flags) {
+    const { logger } = context;
+    logger.debug('Displaying help menu using command and flag structures.');
+    const commandColumnWidth = Math.max(...commands.map((cmd)=>cmd.name.length), 10) + 2;
+    const commandLines = commands.map((cmd)=>`  ${cmd.name.padEnd(commandColumnWidth)}${cmd.description}`).join('\n');
+    const flagDisplays = flags.map((flag)=>{
+        const names = flag.names.join(', ');
+        const valuePlaceholder = flag.expectsValue ? ' <value>' : '';
+        return names + valuePlaceholder;
+    });
+    const optionColumnWidth = Math.max(...flagDisplays.map((flag)=>flag.length), 20) + 2;
+    const optionLines = flags.map((flag, index)=>{
+        const display = flagDisplays[index] ?? '';
+        return `  ${display.padEnd(optionColumnWidth)}${flag.description}`;
+    }).join('\n');
+    const helpContent = `c15t CLI version ${version}
+
+Available Commands:
+${commandLines}
+
+Options:
+${optionLines}
+
+Run a command directly (e.g., ${external_picocolors_["default"].cyan('c15t setup')}) or select one interactively when no command is provided.
+
+For more help, visit: https://v2.c15t.com`;
+    logger.debug('Help menu content generated.');
+    logger.note(helpContent, 'Usage');
+}
+var promises_ = __webpack_require__("node:fs/promises");
+var external_node_path_ = __webpack_require__("node:path");
+var external_ts_morph_ = __webpack_require__("ts-morph");
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const BOOLEAN_STATE_PROPERTIES = {
+    showPopup: 'banner',
+    isPrivacyDialogOpen: 'dialog'
+};
+const LEGACY_SETTER_NAMES = {
+    setShowPopup: 'banner',
+    setIsPrivacyDialogOpen: 'dialog'
+};
+function getBindingPropertyName(element) {
+    const propertyNameNode = element.getPropertyNameNode();
+    if (propertyNameNode) {
+        if (external_ts_morph_.Node.isIdentifier(propertyNameNode)) return propertyNameNode.getText();
+        if (external_ts_morph_.Node.isStringLiteral(propertyNameNode)) return propertyNameNode.getLiteralText();
+        return;
+    }
+    const nameNode = element.getNameNode();
+    if (!external_ts_morph_.Node.isIdentifier(nameNode)) return;
+    return nameNode.getText();
+}
+function mapBooleanExpressionToUi(expressionText, activeValue) {
+    const trimmed = expressionText?.trim();
+    if (!trimmed || 'true' === trimmed) return `'${activeValue}'`;
+    if ('false' === trimmed) return "'none'";
+    return `${trimmed} ? '${activeValue}' : 'none'`;
+}
+function mapShowPopupCall(callee, args) {
+    const uiArgument = mapBooleanExpressionToUi(args[0], 'banner');
+    const forceArg = args[1]?.trim();
+    if (!forceArg || 'false' === forceArg || 'undefined' === forceArg) return {
+        text: `${callee}(${uiArgument})`,
+        operations: 1
+    };
+    if ('true' === forceArg) return {
+        text: `${callee}(${uiArgument}, { force: true })`,
+        operations: 1
+    };
+    return {
+        text: `${callee}(${uiArgument}, ${forceArg} ? { force: true } : undefined)`,
+        operations: 1
+    };
+}
+function mapPrivacyDialogCall(callee, args) {
+    const uiArgument = mapBooleanExpressionToUi(args[0], 'dialog');
+    return `${callee}(${uiArgument})`;
+}
+function transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const booleanAliases = new Map();
+    const setterAliases = new Map();
+    const bindingElements = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.BindingElement);
+    for (const element of bindingElements){
+        const propertyName = getBindingPropertyName(element);
+        if (!propertyName) continue;
+        const localNameNode = element.getNameNode();
+        if (!external_ts_morph_.Node.isIdentifier(localNameNode)) continue;
+        const localName = localNameNode.getText();
+        if (propertyName in BOOLEAN_STATE_PROPERTIES) {
+            const stateValue = BOOLEAN_STATE_PROPERTIES[propertyName];
+            booleanAliases.set(localName, stateValue);
+            const propertyNameNode = element.getPropertyNameNode();
+            if (propertyNameNode) propertyNameNode.replaceWithText('activeUI');
+            else {
+                const initializerText = element.getInitializer()?.getText();
+                let replacement = `activeUI: ${localName}`;
+                if (initializerText) replacement += ` = ${initializerText}`;
+                element.replaceWithText(replacement);
+            }
+            operations += 1;
+            summaries.push(`${propertyName} -> activeUI`);
+            continue;
+        }
+        if (propertyName in LEGACY_SETTER_NAMES) {
+            setterAliases.set(localName, propertyName);
+            const propertyNameNode = element.getPropertyNameNode();
+            if (propertyNameNode) propertyNameNode.replaceWithText('setActiveUI');
+            else {
+                const initializerText = element.getInitializer()?.getText();
+                let replacement = `setActiveUI: ${localName}`;
+                if (initializerText) replacement += ` = ${initializerText}`;
+                element.replaceWithText(replacement);
+            }
+            operations += 1;
+            summaries.push(`${propertyName} -> setActiveUI alias`);
+        }
+    }
+    const callExpressions = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.CallExpression);
+    for (const callExpression of callExpressions){
+        const expression = callExpression.getExpression();
+        const args = callExpression.getArguments().map((argument)=>argument.getText());
+        if (external_ts_morph_.Node.isPropertyAccessExpression(expression)) {
+            const methodName = expression.getName();
+            if (!(methodName in LEGACY_SETTER_NAMES)) continue;
+            const receiver = expression.getExpression().getText();
+            const callee = `${receiver}.setActiveUI`;
+            let replacement = '';
+            if ('setShowPopup' === methodName) {
+                replacement = mapShowPopupCall(callee, args).text;
+                summaries.push('setShowPopup(...) -> setActiveUI(...)');
+            } else {
+                replacement = mapPrivacyDialogCall(callee, args);
+                summaries.push('setIsPrivacyDialogOpen(...) -> setActiveUI(...)');
+            }
+            callExpression.replaceWithText(replacement);
+            operations += 1;
+            continue;
+        }
+        if (!external_ts_morph_.Node.isIdentifier(expression)) continue;
+        const calleeName = expression.getText();
+        const aliasKind = setterAliases.get(calleeName);
+        if (aliasKind) {
+            if ('setShowPopup' === aliasKind) {
+                const mapped = mapShowPopupCall(calleeName, args);
+                callExpression.replaceWithText(mapped.text);
+                summaries.push('setShowPopup alias call -> setActiveUI args');
+            } else {
+                callExpression.replaceWithText(mapPrivacyDialogCall(calleeName, args));
+                summaries.push('setIsPrivacyDialogOpen alias call -> setActiveUI args');
+            }
+            operations += 1;
+        }
+    }
+    const propertyAccesses = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAccessExpression);
+    for (const propertyAccess of propertyAccesses){
+        const propertyName = propertyAccess.getName();
+        if (!(propertyName in BOOLEAN_STATE_PROPERTIES)) continue;
+        const parent = propertyAccess.getParent();
+        if (external_ts_morph_.Node.isBinaryExpression(parent) && parent.getLeft() === propertyAccess) continue;
+        const receiver = propertyAccess.getExpression().getText();
+        const activeValue = BOOLEAN_STATE_PROPERTIES[propertyName];
+        propertyAccess.replaceWithText(`(${receiver}.activeUI === '${activeValue}')`);
+        operations += 1;
+        summaries.push(`${propertyName} state check -> activeUI comparison`);
+    }
+    const identifiers = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.Identifier);
+    for (const identifier of identifiers){
+        if (identifier.wasForgotten()) continue;
+        const identifierText = identifier.getText();
+        const aliasTarget = booleanAliases.get(identifierText);
+        if (!aliasTarget) continue;
+        const parent = identifier.getParent();
+        if (!external_ts_morph_.Node.isBindingElement(parent) || parent.getNameNode() !== identifier) {
+            if (!external_ts_morph_.Node.isPropertyAccessExpression(parent) || parent.getNameNode() !== identifier) {
+                if (!external_ts_morph_.Node.isPropertyAssignment(parent) || parent.getNameNode() !== identifier) {
+                    if (external_ts_morph_.Node.isShorthandPropertyAssignment(parent)) {
+                        const name = identifierText;
+                        parent.replaceWithText(`${name}: (${name} === '${aliasTarget}')`);
+                        operations += 1;
+                        summaries.push(`${name} shorthand -> activeUI comparison`);
+                        continue;
+                    }
+                    identifier.replaceWithText(`(${identifierText} === '${aliasTarget}')`);
+                    operations += 1;
+                    summaries.push(`${identifierText} usage -> activeUI comparison`);
+                }
+            }
+        }
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runActiveUiApiCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const component_renames_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const component_renames_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const C15T_REACT_PACKAGES = new Set([
+    '@c15t/react',
+    '@c15t/nextjs'
+]);
+const RENAME_MAP = {
+    CookieBanner: 'ConsentBanner',
+    ConsentManagerDialog: 'ConsentDialog',
+    ConsentManagerWidget: 'ConsentWidget',
+    CookieBannerProps: 'ConsentBannerProps',
+    ConsentManagerDialogProps: 'ConsentDialogProps',
+    ConsentManagerWidgetProps: 'ConsentWidgetProps'
+};
+function hasLegacyC15tComponentImport(sourceFile) {
+    for (const importDeclaration of sourceFile.getImportDeclarations()){
+        const specifier = importDeclaration.getModuleSpecifierValue();
+        if (C15T_REACT_PACKAGES.has(specifier)) for (const namedImport of importDeclaration.getNamedImports()){
+            const importedName = namedImport.getNameNode().getText();
+            if (importedName in RENAME_MAP) return true;
+        }
+    }
+    return false;
+}
+function component_renames_transformSourceFile(sourceFile) {
+    if (!hasLegacyC15tComponentImport(sourceFile)) return {
+        changed: false,
+        operations: 0,
+        summaries: []
+    };
+    let operations = 0;
+    const summaries = [];
+    const identifiers = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.Identifier);
+    for (const identifier of identifiers){
+        const identifierText = identifier.getText();
+        if (!(identifierText in RENAME_MAP)) continue;
+        const replacement = RENAME_MAP[identifierText];
+        const parent = identifier.getParent();
+        if (external_ts_morph_.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) continue;
+        if (!external_ts_morph_.Node.isPropertyAccessExpression(parent) || parent.getNameNode() !== identifier) {
+            if (!external_ts_morph_.Node.isImportSpecifier(parent) || parent.getAliasNode() !== identifier) {
+                if (!external_ts_morph_.Node.isShorthandPropertyAssignment(parent) || parent.getNameNode() !== identifier) {
+                    identifier.replaceWithText(replacement);
+                    operations += 1;
+                    summaries.push(`${identifierText} -> ${replacement}`);
+                }
+            }
+        }
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function component_renames_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (component_renames_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (component_renames_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runComponentRenamesCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await component_renames_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = component_renames_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const gdpr_types_to_consent_categories_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const gdpr_types_to_consent_categories_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const LEGACY_KEYS = new Set([
+    'gdprTypes',
+    'initialGDPRTypes'
+]);
+const NEXT_KEY = 'consentCategories';
+function getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function objectHasConsentCategories(objectLiteral) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (getPropertyName(property) === NEXT_KEY) return true;
+    }
+    return false;
+}
+function gdpr_types_to_consent_categories_getBindingPropertyName(element) {
+    const propertyNameNode = element.getPropertyNameNode();
+    if (propertyNameNode) {
+        if (external_ts_morph_.Node.isIdentifier(propertyNameNode)) return propertyNameNode.getText();
+        if (external_ts_morph_.Node.isStringLiteral(propertyNameNode)) return propertyNameNode.getLiteralText();
+        return;
+    }
+    const nameNode = element.getNameNode();
+    if (!external_ts_morph_.Node.isIdentifier(nameNode)) return;
+    return nameNode.getText();
+}
+function gdpr_types_to_consent_categories_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        const name = getPropertyName(property);
+        if (!LEGACY_KEYS.has(name)) continue;
+        const parent = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!(parent && objectHasConsentCategories(parent))) {
+            property.getNameNode().replaceWithText(NEXT_KEY);
+            operations += 1;
+            summaries.push(`${name} -> ${NEXT_KEY}`);
+        }
+    }
+    const shorthandAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.ShorthandPropertyAssignment);
+    for (const shorthand of shorthandAssignments){
+        const name = shorthand.getNameNode().getText();
+        if (!LEGACY_KEYS.has(name)) continue;
+        const parent = shorthand.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!(parent && objectHasConsentCategories(parent))) {
+            shorthand.replaceWithText(`${NEXT_KEY}: ${name}`);
+            operations += 1;
+            summaries.push(`${name} shorthand -> ${NEXT_KEY}`);
+        }
+    }
+    const bindingElements = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.BindingElement);
+    for (const element of bindingElements){
+        const propertyName = gdpr_types_to_consent_categories_getBindingPropertyName(element);
+        if (!propertyName || !LEGACY_KEYS.has(propertyName)) continue;
+        const propertyNameNode = element.getPropertyNameNode();
+        if (propertyNameNode) propertyNameNode.replaceWithText(NEXT_KEY);
+        else {
+            const nameNode = element.getNameNode();
+            if (!external_ts_morph_.Node.isIdentifier(nameNode)) continue;
+            const localName = nameNode.getText();
+            const initializerText = element.getInitializer()?.getText();
+            let replacement = `${NEXT_KEY}: ${localName}`;
+            if (initializerText) replacement += ` = ${initializerText}`;
+            element.replaceWithText(replacement);
+        }
+        operations += 1;
+        summaries.push(`${propertyName} destructuring -> ${NEXT_KEY}`);
+    }
+    const propertyAccesses = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAccessExpression);
+    for (const propertyAccess of propertyAccesses){
+        const name = propertyAccess.getName();
+        if (!LEGACY_KEYS.has(name)) continue;
+        const expressionText = propertyAccess.getExpression().getText();
+        propertyAccess.replaceWithText(`${expressionText}.${NEXT_KEY}`);
+        operations += 1;
+        summaries.push(`${name} access -> ${NEXT_KEY}`);
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function gdpr_types_to_consent_categories_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (gdpr_types_to_consent_categories_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (gdpr_types_to_consent_categories_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runGdprTypesToConsentCategoriesCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await gdpr_types_to_consent_categories_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = gdpr_types_to_consent_categories_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const ignore_geo_location_to_overrides_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const ignore_geo_location_to_overrides_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const LEGACY_KEY = 'ignoreGeoLocation';
+const ignore_geo_location_to_overrides_NEXT_KEY = 'overrides';
+const DEFAULT_COUNTRY_CODE = 'DE';
+function ignore_geo_location_to_overrides_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function getProperty(objectLiteral, name) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (ignore_geo_location_to_overrides_getPropertyName(property) === name) return property;
+    }
+}
+function objectHasCountry(objectLiteral) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if ('country' === ignore_geo_location_to_overrides_getPropertyName(property)) return true;
+    }
+    return false;
+}
+function mergeCountryIntoOverridesExpression(overridesExpressionText, ignoreExpressionText) {
+    if ('true' === ignoreExpressionText) return `{ ...(${overridesExpressionText}), country: (${overridesExpressionText})?.country ?? '${DEFAULT_COUNTRY_CODE}' }`;
+    if ('false' === ignoreExpressionText) return overridesExpressionText;
+    return `${ignoreExpressionText} ? { ...(${overridesExpressionText}), country: (${overridesExpressionText})?.country ?? '${DEFAULT_COUNTRY_CODE}' } : (${overridesExpressionText})`;
+}
+function ignore_geo_location_to_overrides_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if (property.wasForgotten() || ignore_geo_location_to_overrides_getPropertyName(property) !== LEGACY_KEY) continue;
+        const parentObject = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!parentObject) continue;
+        const ignoreExpressionText = property.getInitializer()?.getText()?.trim() ?? 'true';
+        const overridesProperty = getProperty(parentObject, ignore_geo_location_to_overrides_NEXT_KEY);
+        if (!overridesProperty) {
+            if ('false' === ignoreExpressionText) {
+                property.remove();
+                operations += 1;
+                summaries.push('removed ignoreGeoLocation: false');
+                continue;
+            }
+            property.getNameNode().replaceWithText(ignore_geo_location_to_overrides_NEXT_KEY);
+            if ('true' === ignoreExpressionText) {
+                property.setInitializer(`{ country: '${DEFAULT_COUNTRY_CODE}' }`);
+                summaries.push('ignoreGeoLocation -> overrides.country');
+            } else {
+                property.setInitializer(`${ignoreExpressionText} ? { country: '${DEFAULT_COUNTRY_CODE}' } : undefined`);
+                summaries.push('ignoreGeoLocation expression -> conditional overrides.country');
+            }
+            operations += 1;
+            continue;
+        }
+        const overridesInitializer = overridesProperty.getInitializer();
+        const overridesObject = overridesInitializer?.asKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (overridesObject) {
+            if (!objectHasCountry(overridesObject)) {
+                if ('true' === ignoreExpressionText) {
+                    overridesObject.addPropertyAssignment({
+                        name: 'country',
+                        initializer: `'${DEFAULT_COUNTRY_CODE}'`
+                    });
+                    summaries.push('merged ignoreGeoLocation into overrides.country');
+                    operations += 1;
+                } else if ('false' !== ignoreExpressionText) {
+                    overridesObject.addPropertyAssignment({
+                        name: 'country',
+                        initializer: `${ignoreExpressionText} ? '${DEFAULT_COUNTRY_CODE}' : undefined`
+                    });
+                    summaries.push('merged ignoreGeoLocation expression into overrides.country');
+                    operations += 1;
+                }
+            }
+        } else if (overridesInitializer) {
+            const mergedExpression = mergeCountryIntoOverridesExpression(overridesInitializer.getText().trim(), ignoreExpressionText);
+            if (mergedExpression !== overridesInitializer.getText().trim()) {
+                overridesProperty.setInitializer(mergedExpression);
+                summaries.push('merged ignoreGeoLocation into existing overrides expression');
+                operations += 1;
+            }
+        }
+        property.remove();
+        operations += 1;
+        summaries.push('removed ignoreGeoLocation property');
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function ignore_geo_location_to_overrides_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (ignore_geo_location_to_overrides_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (ignore_geo_location_to_overrides_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runIgnoreGeoLocationToOverridesCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await ignore_geo_location_to_overrides_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = ignore_geo_location_to_overrides_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const mode_c15t_to_hosted_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const mode_c15t_to_hosted_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+function mode_c15t_to_hosted_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function mode_c15t_to_hosted_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if ('mode' !== mode_c15t_to_hosted_getPropertyName(property)) continue;
+        const initializer = property.getInitializerIfKind(external_ts_morph_.SyntaxKind.StringLiteral);
+        if (initializer) {
+            if ('c15t' === initializer.getLiteralValue()) {
+                initializer.setLiteralValue('hosted');
+                operations += 1;
+                summaries.push("mode 'c15t' -> 'hosted'");
+            }
+        }
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function mode_c15t_to_hosted_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (mode_c15t_to_hosted_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (mode_c15t_to_hosted_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runC15tModeToHostedCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await mode_c15t_to_hosted_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = mode_c15t_to_hosted_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const offline_add_policy_packs_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const offline_add_policy_packs_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+function offline_add_policy_packs_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function offline_add_policy_packs_getProperty(objectLiteral, name) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (offline_add_policy_packs_getPropertyName(property) === name) return property;
+    }
+}
+const STARTER_POLICY_PACK = '[\n\t\t\tpolicyPackPresets.europeOptIn(),\n\t\t\tpolicyPackPresets.californiaOptOut(),\n\t\t\tpolicyPackPresets.worldNoBanner(),\n\t\t]';
+function offline_add_policy_packs_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    let needsImport = false;
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if (property.wasForgotten() || 'mode' !== offline_add_policy_packs_getPropertyName(property)) continue;
+        const initializer = property.getInitializerIfKind(external_ts_morph_.SyntaxKind.StringLiteral);
+        if (!initializer || 'offline' !== initializer.getLiteralValue()) continue;
+        const configObject = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!configObject) continue;
+        const offlinePolicyProperty = offline_add_policy_packs_getProperty(configObject, 'offlinePolicy');
+        if (offlinePolicyProperty) {
+            const offlinePolicyObject = offlinePolicyProperty.getInitializerIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+            if (offlinePolicyObject && offline_add_policy_packs_getProperty(offlinePolicyObject, 'policyPacks')) continue;
+        }
+        if (offlinePolicyProperty) {
+            const offlinePolicyObject = offlinePolicyProperty.getInitializerIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+            if (offlinePolicyObject) {
+                offlinePolicyObject.addPropertyAssignment({
+                    name: 'policyPacks',
+                    initializer: STARTER_POLICY_PACK
+                });
+                operations += 1;
+                needsImport = true;
+                summaries.push('added policyPacks: starter presets');
+            }
+        } else {
+            configObject.addPropertyAssignment({
+                name: 'offlinePolicy',
+                initializer: `{\n\t\tpolicyPacks: ${STARTER_POLICY_PACK},\n\t}`
+            });
+            operations += 1;
+            needsImport = true;
+            summaries.push('added offlinePolicy.policyPacks with starter presets');
+        }
+    }
+    if (needsImport) {
+        const existingImports = sourceFile.getImportDeclarations();
+        const alreadyImported = existingImports.some((decl)=>{
+            const namedImports = decl.getNamedImports();
+            return namedImports.some((ni)=>'policyPackPresets' === ni.getName());
+        });
+        if (!alreadyImported) {
+            const c15tImport = existingImports.find((decl)=>{
+                const moduleSpecifier = decl.getModuleSpecifierValue();
+                return 'c15t' === moduleSpecifier || '@c15t/react' === moduleSpecifier || '@c15t/nextjs' === moduleSpecifier;
+            });
+            if (c15tImport) {
+                c15tImport.addNamedImport('policyPackPresets');
+                summaries.push('added policyPackPresets to existing import');
+            } else {
+                sourceFile.addImportDeclaration({
+                    namedImports: [
+                        'policyPackPresets'
+                    ],
+                    moduleSpecifier: 'c15t'
+                });
+                summaries.push("added import { policyPackPresets } from 'c15t'");
+            }
+            operations += 1;
+        }
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function offline_add_policy_packs_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (offline_add_policy_packs_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (offline_add_policy_packs_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runOfflineAddPolicyPacksCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await offline_add_policy_packs_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = offline_add_policy_packs_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const react_options_to_top_level_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const react_options_to_top_level_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const UI_OPTION_KEYS = [
+    'theme',
+    'colorScheme',
+    'disableAnimation'
+];
+function react_options_to_top_level_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function react_options_to_top_level_getProperty(objectLiteral, name) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (react_options_to_top_level_getPropertyName(property) === name) return property;
+    }
+}
+function react_options_to_top_level_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if (property.wasForgotten()) continue;
+        if ('react' !== react_options_to_top_level_getPropertyName(property)) continue;
+        const parentObject = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!parentObject) continue;
+        const reactObject = property.getInitializerIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (reactObject) {
+            for (const key of UI_OPTION_KEYS){
+                const nestedProperty = react_options_to_top_level_getProperty(reactObject, key);
+                if (!nestedProperty) continue;
+                const initializerText = nestedProperty.getInitializer()?.getText();
+                if (initializerText) {
+                    if (react_options_to_top_level_getProperty(parentObject, key)) summaries.push(`removed duplicate react.${key}`);
+                    else {
+                        parentObject.addPropertyAssignment({
+                            name: key,
+                            initializer: initializerText
+                        });
+                        summaries.push(`react.${key} -> ${key}`);
+                    }
+                    nestedProperty.remove();
+                    operations += 1;
+                }
+            }
+            if (0 === reactObject.getProperties().length) {
+                property.remove();
+                operations += 1;
+                summaries.push('removed empty react options object');
+            }
+        }
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function react_options_to_top_level_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (react_options_to_top_level_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (react_options_to_top_level_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runReactOptionsToTopLevelCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await react_options_to_top_level_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = react_options_to_top_level_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const tracking_blocker_to_network_blocker_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const tracking_blocker_to_network_blocker_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+const LEGACY_CONFIG_KEY = 'trackingBlockerConfig';
+const NEXT_CONFIG_KEY = 'networkBlocker';
+const LEGACY_TYPE_NAME = 'TrackingBlockerConfig';
+const NEXT_TYPE_NAME = 'NetworkBlockerConfig';
+const C15T_PACKAGES = new Set([
+    'c15t',
+    '@c15t/react',
+    '@c15t/nextjs'
+]);
+function tracking_blocker_to_network_blocker_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function tracking_blocker_to_network_blocker_getProperty(objectLiteral, name) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (tracking_blocker_to_network_blocker_getPropertyName(property) === name) return property;
+    }
+}
+function invertExpression(expressionText) {
+    const trimmed = expressionText.trim();
+    if ('true' === trimmed) return 'false';
+    if ('false' === trimmed) return 'true';
+    if (trimmed.startsWith('!')) return trimmed.slice(1).trim();
+    return `!(${trimmed})`;
+}
+function getObjectPropertyKeyText(property) {
+    if (!external_ts_morph_.Node.isPropertyAssignment(property)) return;
+    const nameNode = property.getNameNode();
+    if (external_ts_morph_.Node.isIdentifier(nameNode)) return nameNode.getText();
+    if (external_ts_morph_.Node.isStringLiteral(nameNode)) return nameNode.getLiteralText();
+    const raw = nameNode.getText();
+    return raw.replace(/^['"]|['"]$/g, '');
+}
+function buildRulesExpression(domainConsentMapInitializer) {
+    const domainMapObject = domainConsentMapInitializer.asKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+    if (!domainMapObject) {
+        const expressionText = domainConsentMapInitializer.getText();
+        return `Object.entries(${expressionText}).map(([domain, category]) => ({ domain, category }))`;
+    }
+    const entries = [];
+    for (const property of domainMapObject.getProperties()){
+        if (!external_ts_morph_.Node.isPropertyAssignment(property)) continue;
+        const key = getObjectPropertyKeyText(property);
+        const value = property.getInitializer()?.getText();
+        if (key && value) entries.push(`{ domain: '${key}', category: ${value} }`);
+    }
+    if (0 === entries.length) {
+        const expressionText = domainConsentMapInitializer.getText();
+        return `Object.entries(${expressionText}).map(([domain, category]) => ({ domain, category }))`;
+    }
+    return `[${entries.join(', ')}]`;
+}
+function migrateTrackingBlockerObject(trackingObject) {
+    const disableAutomaticBlockingProperty = tracking_blocker_to_network_blocker_getProperty(trackingObject, 'disableAutomaticBlocking');
+    const domainConsentMapProperty = tracking_blocker_to_network_blocker_getProperty(trackingObject, 'domainConsentMap');
+    const enabledLine = disableAutomaticBlockingProperty ? `enabled: ${invertExpression(disableAutomaticBlockingProperty.getInitializer()?.getText() ?? 'false')},` : '';
+    const rulesExpression = domainConsentMapProperty?.getInitializer() ? buildRulesExpression(domainConsentMapProperty.getInitializer()) : '[]';
+    const lines = [
+        `rules: ${rulesExpression},`
+    ];
+    if (enabledLine) lines.unshift(enabledLine);
+    return `{
+		${lines.join('\n\t\t')}
+	}`;
+}
+function tracking_blocker_to_network_blocker_getBindingPropertyName(element) {
+    const propertyNameNode = element.getPropertyNameNode();
+    if (propertyNameNode) {
+        if (external_ts_morph_.Node.isIdentifier(propertyNameNode)) return propertyNameNode.getText();
+        if (external_ts_morph_.Node.isStringLiteral(propertyNameNode)) return propertyNameNode.getLiteralText();
+        return;
+    }
+    const nameNode = element.getNameNode();
+    if (!external_ts_morph_.Node.isIdentifier(nameNode)) return;
+    return nameNode.getText();
+}
+function tracking_blocker_to_network_blocker_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    let hasC15tTrackingTypeImport = false;
+    const imports = sourceFile.getImportDeclarations();
+    for (const importDeclaration of imports)if (C15T_PACKAGES.has(importDeclaration.getModuleSpecifierValue())) {
+        for (const namedImport of importDeclaration.getNamedImports())if (namedImport.getNameNode().getText() === LEGACY_TYPE_NAME) {
+            namedImport.getNameNode().replaceWithText(NEXT_TYPE_NAME);
+            hasC15tTrackingTypeImport = true;
+            operations += 1;
+            summaries.push(`${LEGACY_TYPE_NAME} -> ${NEXT_TYPE_NAME}`);
+        }
+    }
+    if (hasC15tTrackingTypeImport) {
+        const identifiers = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.Identifier);
+        for (const identifier of identifiers){
+            if (identifier.getText() !== LEGACY_TYPE_NAME) continue;
+            const parent = identifier.getParent();
+            if (!external_ts_morph_.Node.isImportSpecifier(parent) || parent.getNameNode() !== identifier) {
+                identifier.replaceWithText(NEXT_TYPE_NAME);
+                operations += 1;
+                summaries.push(`${LEGACY_TYPE_NAME} references -> ${NEXT_TYPE_NAME}`);
+            }
+        }
+    }
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if (property.wasForgotten()) continue;
+        if (tracking_blocker_to_network_blocker_getPropertyName(property) !== LEGACY_CONFIG_KEY) continue;
+        const parentObject = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!parentObject) continue;
+        if (tracking_blocker_to_network_blocker_getProperty(parentObject, NEXT_CONFIG_KEY)) continue;
+        const initializer = property.getInitializer();
+        const trackingObject = initializer?.asKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (trackingObject) {
+            property.getNameNode().replaceWithText(NEXT_CONFIG_KEY);
+            property.setInitializer(migrateTrackingBlockerObject(trackingObject));
+            operations += 1;
+            summaries.push('trackingBlockerConfig object -> networkBlocker rules/enabled');
+            continue;
+        }
+        property.getNameNode().replaceWithText(NEXT_CONFIG_KEY);
+        operations += 1;
+        summaries.push('trackingBlockerConfig -> networkBlocker');
+    }
+    const shorthandAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.ShorthandPropertyAssignment);
+    for (const shorthand of shorthandAssignments){
+        const name = shorthand.getNameNode().getText();
+        if (name !== LEGACY_CONFIG_KEY) continue;
+        const parent = shorthand.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!(parent && tracking_blocker_to_network_blocker_getProperty(parent, NEXT_CONFIG_KEY))) {
+            shorthand.replaceWithText(`${NEXT_CONFIG_KEY}: ${name}`);
+            operations += 1;
+            summaries.push('trackingBlockerConfig shorthand -> networkBlocker');
+        }
+    }
+    const bindingElements = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.BindingElement);
+    for (const element of bindingElements){
+        const propertyName = tracking_blocker_to_network_blocker_getBindingPropertyName(element);
+        if (propertyName !== LEGACY_CONFIG_KEY) continue;
+        const propertyNameNode = element.getPropertyNameNode();
+        if (propertyNameNode) propertyNameNode.replaceWithText(NEXT_CONFIG_KEY);
+        else {
+            const nameNode = element.getNameNode();
+            if (!external_ts_morph_.Node.isIdentifier(nameNode)) continue;
+            const localName = nameNode.getText();
+            const initializerText = element.getInitializer()?.getText();
+            let replacement = `${NEXT_CONFIG_KEY}: ${localName}`;
+            if (initializerText) replacement += ` = ${initializerText}`;
+            element.replaceWithText(replacement);
+        }
+        operations += 1;
+        summaries.push('trackingBlockerConfig destructuring -> networkBlocker');
+    }
+    const propertyAccesses = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAccessExpression);
+    for (const propertyAccess of propertyAccesses){
+        if (propertyAccess.getName() !== LEGACY_CONFIG_KEY) continue;
+        const expressionText = propertyAccess.getExpression().getText();
+        propertyAccess.replaceWithText(`${expressionText}.${NEXT_CONFIG_KEY}`);
+        operations += 1;
+        summaries.push('trackingBlockerConfig access -> networkBlocker');
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function tracking_blocker_to_network_blocker_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isSymbolicLink()) continue;
+            if (entry.isDirectory()) {
+                if (tracking_blocker_to_network_blocker_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (tracking_blocker_to_network_blocker_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runTrackingBlockerToNetworkBlockerCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await tracking_blocker_to_network_blocker_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = tracking_blocker_to_network_blocker_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const translations_to_i18n_SUPPORTED_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx'
+]);
+const translations_to_i18n_IGNORED_DIRS = new Set([
+    '.git',
+    '.next',
+    '.turbo',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out'
+]);
+function translations_to_i18n_getPropertyName(property) {
+    const rawName = property.getNameNode().getText().trim();
+    return rawName.replace(/^['"]|['"]$/g, '');
+}
+function translations_to_i18n_getProperty(objectLiteral, name) {
+    for (const property of objectLiteral.getProperties())if (external_ts_morph_.Node.isPropertyAssignment(property)) {
+        if (translations_to_i18n_getPropertyName(property) === name) return property;
+    }
+}
+function hasProperty(objectLiteral, name) {
+    return Boolean(translations_to_i18n_getProperty(objectLiteral, name));
+}
+function renameProperty(property, nextName) {
+    property.getNameNode().replaceWithText(nextName);
+}
+function isLegacyTranslationConfigObject(objectLiteral) {
+    const hasDefaultLanguage = hasProperty(objectLiteral, 'defaultLanguage');
+    const hasDisableAutoLanguageSwitch = hasProperty(objectLiteral, 'disableAutoLanguageSwitch');
+    const hasTranslations = hasProperty(objectLiteral, 'translations');
+    const hasLanguage = hasProperty(objectLiteral, 'language');
+    const hasI18n = hasProperty(objectLiteral, 'i18n');
+    const hasMessages = hasProperty(objectLiteral, 'messages');
+    const hasLocale = hasProperty(objectLiteral, 'locale');
+    if (hasDefaultLanguage || hasDisableAutoLanguageSwitch) return true;
+    if (hasTranslations && !hasLanguage && !hasI18n && !hasMessages && !hasLocale) return true;
+    return false;
+}
+function translations_to_i18n_invertExpression(expressionText) {
+    const trimmed = expressionText.trim();
+    if ('true' === trimmed) return 'false';
+    if ('false' === trimmed) return 'true';
+    if (trimmed.startsWith('!')) return trimmed.slice(1).trim();
+    return `!(${trimmed})`;
+}
+function transformLegacyConfigObject(objectLiteral) {
+    let operations = 0;
+    const summaries = [];
+    const translationsProperty = translations_to_i18n_getProperty(objectLiteral, 'translations');
+    if (translationsProperty && !hasProperty(objectLiteral, 'messages')) {
+        renameProperty(translationsProperty, 'messages');
+        operations += 1;
+        summaries.push('translations -> messages');
+    }
+    const defaultLanguageProperty = translations_to_i18n_getProperty(objectLiteral, 'defaultLanguage');
+    if (defaultLanguageProperty && !hasProperty(objectLiteral, 'locale')) {
+        renameProperty(defaultLanguageProperty, 'locale');
+        operations += 1;
+        summaries.push('defaultLanguage -> locale');
+    }
+    const disableAutoSwitchProperty = translations_to_i18n_getProperty(objectLiteral, 'disableAutoLanguageSwitch');
+    if (disableAutoSwitchProperty && !hasProperty(objectLiteral, 'detectBrowserLanguage')) {
+        const initializer = disableAutoSwitchProperty.getInitializer();
+        const expressionText = initializer?.getText() ?? 'false';
+        renameProperty(disableAutoSwitchProperty, 'detectBrowserLanguage');
+        disableAutoSwitchProperty.setInitializer(translations_to_i18n_invertExpression(expressionText));
+        operations += 1;
+        summaries.push('disableAutoLanguageSwitch -> detectBrowserLanguage');
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries
+    };
+}
+function translations_to_i18n_transformSourceFile(sourceFile) {
+    let operations = 0;
+    const summaries = [];
+    const propertyAssignments = sourceFile.getDescendantsOfKind(external_ts_morph_.SyntaxKind.PropertyAssignment);
+    for (const property of propertyAssignments){
+        if ('translations' !== translations_to_i18n_getPropertyName(property)) continue;
+        const parentObject = property.getParentIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!parentObject) continue;
+        const initializer = property.getInitializerIfKind(external_ts_morph_.SyntaxKind.ObjectLiteralExpression);
+        if (!initializer || !isLegacyTranslationConfigObject(initializer)) continue;
+        if (hasProperty(parentObject, 'i18n')) continue;
+        renameProperty(property, 'i18n');
+        operations += 1;
+        summaries.push('options.translations -> options.i18n');
+        const result = transformLegacyConfigObject(initializer);
+        operations += result.operations;
+        summaries.push(...result.summaries);
+    }
+    return {
+        changed: operations > 0,
+        operations,
+        summaries: [
+            ...new Set(summaries)
+        ]
+    };
+}
+async function translations_to_i18n_collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await (0, promises_.readdir)(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isDirectory()) {
+                if (translations_to_i18n_IGNORED_DIRS.has(entry.name)) continue;
+                await walk((0, external_node_path_.join)(currentDir, entry.name));
+                continue;
+            }
+            if (!entry.isFile()) continue;
+            const extension = (0, external_node_path_.extname)(entry.name).toLowerCase();
+            if (translations_to_i18n_SUPPORTED_EXTENSIONS.has(extension)) files.push((0, external_node_path_.join)(currentDir, entry.name));
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function runTranslationsToI18nCodemod(options) {
+    const project = new external_ts_morph_.Project({
+        skipAddingFilesFromTsConfig: true,
+        compilerOptions: {
+            allowJs: true
+        }
+    });
+    const filePaths = await translations_to_i18n_collectSourceFiles(options.projectRoot);
+    const changedFiles = [];
+    const errors = [];
+    for (const filePath of filePaths)try {
+        const sourceFile = project.addSourceFileAtPathIfExists(filePath);
+        if (!sourceFile) continue;
+        const result = translations_to_i18n_transformSourceFile(sourceFile);
+        if (!result.changed) continue;
+        changedFiles.push({
+            filePath,
+            operations: result.operations,
+            summaries: result.summaries
+        });
+        if (!options.dryRun) await sourceFile.save();
+    } catch (error) {
+        errors.push({
+            filePath,
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return {
+        totalFiles: filePaths.length,
+        changedFiles,
+        errors
+    };
+}
+const C15T_PACKAGE_PREFIX = '@c15t/';
+function parseVersion(raw) {
+    const match = raw.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    if (!match) return null;
+    const [, majorPart, minorPart, patchPart, preReleasePart] = match;
+    if (!majorPart || !minorPart || !patchPart) return null;
+    const major = Number.parseInt(majorPart, 10);
+    const minor = Number.parseInt(minorPart, 10);
+    const patch = Number.parseInt(patchPart, 10);
+    const preRelease = preReleasePart ? preReleasePart.split('.') : [];
+    return {
+        major,
+        minor,
+        patch,
+        preRelease
+    };
+}
+function extractVersionFromSpecifier(specifier) {
+    const match = specifier.match(/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/);
+    if (!match) return null;
+    const [, version] = match;
+    return version ?? null;
+}
+function isNumericSegment(value) {
+    return /^\d+$/.test(value);
+}
+function comparePreRelease(a, b) {
+    if (0 === a.length && 0 === b.length) return 0;
+    if (0 === a.length) return 1;
+    if (0 === b.length) return -1;
+    const maxLength = Math.max(a.length, b.length);
+    for(let index = 0; index < maxLength; index += 1){
+        const aValue = a[index];
+        const bValue = b[index];
+        if (void 0 === aValue) return -1;
+        if (void 0 === bValue) return 1;
+        const aNumeric = isNumericSegment(aValue);
+        const bNumeric = isNumericSegment(bValue);
+        if (aNumeric && bNumeric) {
+            const aNumber = Number.parseInt(aValue, 10);
+            const bNumber = Number.parseInt(bValue, 10);
+            if (aNumber !== bNumber) return aNumber > bNumber ? 1 : -1;
+            continue;
+        }
+        if (aNumeric && !bNumeric) return -1;
+        if (!aNumeric && bNumeric) return 1;
+        if (aValue !== bValue) return aValue > bValue ? 1 : -1;
+    }
+    return 0;
+}
+function compareVersions(a, b) {
+    const parsedA = parseVersion(a);
+    const parsedB = parseVersion(b);
+    if (!parsedA || !parsedB) return null;
+    if (parsedA.major !== parsedB.major) return parsedA.major > parsedB.major ? 1 : -1;
+    if (parsedA.minor !== parsedB.minor) return parsedA.minor > parsedB.minor ? 1 : -1;
+    if (parsedA.patch !== parsedB.patch) return parsedA.patch > parsedB.patch ? 1 : -1;
+    return comparePreRelease(parsedA.preRelease, parsedB.preRelease);
+}
+function satisfiesComparator(version, comparator) {
+    const match = comparator.trim().match(/^(<=|>=|<|>|=)?\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/);
+    if (!match) return false;
+    const [, operatorRaw, target] = match;
+    if (!target) return false;
+    const operator = operatorRaw ?? '=';
+    const comparison = compareVersions(version, target);
+    if (null === comparison) return false;
+    switch(operator){
+        case '<':
+            return comparison < 0;
+        case '<=':
+            return comparison <= 0;
+        case '>':
+            return comparison > 0;
+        case '>=':
+            return comparison >= 0;
+        default:
+            return 0 === comparison;
+    }
+}
+function satisfiesSimpleRange(version, range) {
+    const comparators = range.trim().split(/\s+/).filter(Boolean);
+    if (0 === comparators.length) return true;
+    return comparators.every((comparator)=>satisfiesComparator(version, comparator));
+}
+function isCodemodApplicableForVersion(version, metadata) {
+    if (!version) return true;
+    if (metadata.fromRange && !satisfiesSimpleRange(version, metadata.fromRange)) return false;
+    if (metadata.toRange && satisfiesSimpleRange(version, metadata.toRange)) return false;
+    return true;
+}
+function detectInstalledC15tVersionFromPackageJson(manifest) {
+    const dependencyGroups = [
+        manifest.dependencies,
+        manifest.devDependencies,
+        manifest.peerDependencies,
+        manifest.optionalDependencies
+    ];
+    const versions = [];
+    for (const dependencies of dependencyGroups)if (dependencies) for (const [packageName, specifier] of Object.entries(dependencies)){
+        if ('c15t' !== packageName && !packageName.startsWith(C15T_PACKAGE_PREFIX)) continue;
+        const extracted = extractVersionFromSpecifier(specifier);
+        if (extracted) {
+            if (parseVersion(extracted)) versions.push(extracted);
+        }
+    }
+    if (0 === versions.length) return null;
+    const firstVersion = versions.at(0);
+    if (!firstVersion) return null;
+    let selected = firstVersion;
+    for (const current of versions.slice(1)){
+        const comparison = compareVersions(current, selected);
+        if (null !== comparison && comparison < 0) selected = current;
+    }
+    return selected;
+}
+async function detectInstalledC15tVersion(projectRoot) {
+    const manifestPath = (0, external_node_path_.join)(projectRoot, 'package.json');
+    try {
+        let content;
+        const bunRuntime = globalThis.Bun;
+        if (bunRuntime) content = await bunRuntime.file(manifestPath).text();
+        else {
+            const fs = await import("node:fs/promises");
+            content = await fs.readFile(manifestPath, 'utf-8');
+        }
+        const parsed = JSON.parse(content);
+        return detectInstalledC15tVersionFromPackageJson(parsed);
+    } catch  {
+        return null;
+    }
+}
+function logCodemodResult(context, result, dryRun) {
+    const { logger } = context;
+    if (0 === result.changedFiles.length) {
+        logger.info(`No files needed updates (scanned ${result.totalFiles} source files).`);
+        for (const error of result.errors)logger.warn(`Skipped ${error.filePath}: ${error.error}`);
+        return;
+    }
+    let actionPrefix = 'Applied';
+    if (dryRun) actionPrefix = 'Dry run';
+    logger.success(`${actionPrefix}: updated ${result.changedFiles.length} file(s) out of ${result.totalFiles} scanned.`);
+    for (const file of result.changedFiles){
+        let summary = '';
+        if (file.summaries.length > 0) summary = `: ${file.summaries.join(', ')}`;
+        logger.info(`- ${file.filePath} (${file.operations} changes${summary})`);
+    }
+    for (const error of result.errors)logger.warn(`Skipped ${error.filePath}: ${error.error}`);
+}
+const codemods = [
+    {
+        id: 'active-ui-api',
+        label: 'showPopup API -> activeUI API',
+        hint: 'Migrates showPopup/isPrivacyDialogOpen and setter usage to activeUI.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runActiveUiApiCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
+    },
+    {
+        id: 'component-renames',
+        label: 'legacy component names -> v2 names',
+        hint: 'Renames CookieBanner/ConsentManagerDialog/ConsentManagerWidget.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runComponentRenamesCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
     },
-    "node:fs/promises" (module) {
-        module.exports = __rspack_external_node_fs_promises_153e37e0;
+    {
+        id: 'gdpr-types-to-consent-categories',
+        label: 'gdprTypes -> consentCategories',
+        hint: 'Migrates gdprTypes/initialGDPRTypes to consentCategories.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runGdprTypesToConsentCategoriesCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
     },
-    "node:path" (module) {
-        module.exports = __rspack_external_node_path_c5b9b54f;
+    {
+        id: 'ignore-geo-location-to-overrides',
+        label: 'ignoreGeoLocation -> overrides',
+        hint: "Migrates ignoreGeoLocation to overrides (forces country='DE').",
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runIgnoreGeoLocationToOverridesCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
     },
-    picocolors (module) {
-        module.exports = __rspack_external_picocolors;
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-__webpack_require__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.d = (exports, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.f = {};
-    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
-            __webpack_require__.f[key](chunkId, promises);
-            return promises;
-        }, []));
-})();
-(()=>{
-    __webpack_require__.u = (chunkId)=>"" + chunkId + ".mjs";
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    var installedChunks = {
-        410: 0
-    };
-    var installChunk = (data)=>{
-        var __rspack_esm_ids = data.__rspack_esm_ids;
-        var __webpack_modules__ = data.__webpack_modules__;
-        var __rspack_esm_runtime = data.__rspack_esm_runtime;
-        var moduleId, chunkId, i = 0;
-        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
-        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
-        for(; i < __rspack_esm_ids.length; i++){
-            chunkId = __rspack_esm_ids[i];
-            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
-            installedChunks[__rspack_esm_ids[i]] = 0;
+    {
+        id: 'mode-c15t-to-hosted',
+        label: "mode: 'c15t' -> 'hosted'",
+        hint: "Migrates legacy mode values from 'c15t' to 'hosted'.",
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runC15tModeToHostedCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.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;
+    },
+    {
+        id: 'offline-add-policy-packs',
+        label: 'offline mode -> add policy packs',
+        hint: 'Adds starter policyPackPresets to offline configs missing policies.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runOfflineAddPolicyPacksCodemod({
+                projectRoot,
+                dryRun
             });
-            var promise = Promise.race([
-                promise,
-                new Promise((resolve)=>{
-                    installedChunkData = installedChunks[chunkId] = [
-                        resolve
-                    ];
-                })
-            ]);
-            promises.push(installedChunkData[1] = promise);
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
         }
-    };
-})();
-var prompts_ = __webpack_require__("@clack/prompts");
-var external_picocolors_ = __webpack_require__("picocolors");
-function showHelpMenu(context, version, commands, flags) {
-    const { logger } = context;
-    logger.debug('Displaying help menu using command and flag structures.');
-    const commandLines = commands.map((cmd)=>`  ${cmd.name.padEnd(10)} ${cmd.description}`).join('\n');
-    const optionLines = flags.map((flag)=>{
-        const names = flag.names.join(', ');
-        const valuePlaceholder = flag.expectsValue ? ' <value>' : '';
-        return `  ${(names + valuePlaceholder).padEnd(20)} ${flag.description}`;
-    }).join('\n');
-    const helpContent = `c15t CLI version ${version}
-
-Available Commands:
-${commandLines}
-
-Options:
-${optionLines}
-
-Run a command directly (e.g., ${external_picocolors_["default"].cyan('c15t generate')}) or select one interactively when no command is provided.
-
-For more help, visit: https://c15t.dev`;
-    logger.debug('Help menu content generated.');
-    logger.note(helpContent, 'Usage');
+    },
+    {
+        id: 'react-options-to-top-level',
+        label: 'react options -> top-level options',
+        hint: 'Lifts react.theme/colorScheme/disableAnimation to top-level.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runReactOptionsToTopLevelCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
+    },
+    {
+        id: 'tracking-blocker-to-network-blocker',
+        label: 'trackingBlockerConfig -> networkBlocker',
+        hint: 'Migrates tracking blocker config to network blocker rules.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runTrackingBlockerToNetworkBlockerCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
+    },
+    {
+        id: 'translations-to-i18n',
+        label: 'translations -> i18n',
+        hint: 'Migrates legacy translation config keys to the v2 i18n shape.',
+        run: async (context, dryRun)=>{
+            const { projectRoot } = context;
+            const result = await runTranslationsToI18nCodemod({
+                projectRoot,
+                dryRun
+            });
+            logCodemodResult(context, result, dryRun);
+        },
+        versioning: {
+            fromRange: '<2.0.0',
+            toRange: '>=2.0.0'
+        }
+    }
+];
+async function runCodemods(context) {
+    const { logger, commandArgs, projectRoot } = context;
+    const dryRun = commandArgs.includes('--dry-run');
+    const installedVersion = await detectInstalledC15tVersion(projectRoot);
+    if (installedVersion) logger.info(`Detected c15t version ${installedVersion}.`);
+    else logger.warn('Could not detect c15t version from package.json. Showing all codemods.');
+    const availableCodemods = codemods.filter((codemod)=>isCodemodApplicableForVersion(installedVersion, codemod.versioning ?? {}));
+    if (0 === availableCodemods.length) {
+        if (installedVersion) logger.info(`No codemods are applicable for detected c15t version ${installedVersion}.`);
+        else logger.info('No codemods available.');
+        return;
+    }
+    const selected = await prompts_.multiselect({
+        message: 'Select codemods to run (space to toggle, enter to confirm):',
+        options: availableCodemods.map((codemod)=>({
+                value: codemod.id,
+                label: codemod.label,
+                hint: codemod.hint
+            })),
+        required: false
+    });
+    if (prompts_.isCancel(selected)) return void logger.warn('Codemod execution cancelled.');
+    const selectedCodemods = selected;
+    if (!selectedCodemods.length) return void logger.info('No codemods selected.');
+    let dryRunSuffix = '';
+    if (dryRun) dryRunSuffix = ' in dry-run mode';
+    logger.info(`Running ${selectedCodemods.length} codemod(s)${dryRunSuffix}...`);
+    for (const codemodId of selectedCodemods){
+        const codemod = availableCodemods.find((item)=>item.id === codemodId);
+        if (!codemod) {
+            logger.warn(`Unknown codemod selected: ${codemodId}`);
+            continue;
+        }
+        logger.info(`Running: ${codemod.label}`);
+        await codemod.run(context, dryRun);
+    }
 }
+const codemodsCommand = {
+    name: 'codemods',
+    label: 'Codemods',
+    hint: 'Run migration codemods',
+    description: 'Run project codemods (for example translations -> i18n migration).',
+    action: runCodemods
+};
+var external_node_os_ = __webpack_require__("node:os");
 const TELEMETRY_DISABLED_ENV = 'C15T_TELEMETRY_DISABLED';
 const TelemetryEventName = {
     CLI_INVOKED: 'cli.invoked',
@@ -485,7 +2425,7 @@ class Telemetry {
         }
     }
     generateAnonymousId() {
-        const machineId = __rspack_external_node_crypto_9ba42079["default"].createHash('sha256').update(__rspack_external_node_os_74b4b876["default"].hostname() + __rspack_external_node_os_74b4b876["default"].platform() + __rspack_external_node_os_74b4b876["default"].arch() + __rspack_external_node_os_74b4b876["default"].totalmem()).digest('hex');
+        const machineId = __rspack_external_node_crypto_9ba42079["default"].createHash('sha256').update(external_node_os_["default"].hostname() + external_node_os_["default"].platform() + external_node_os_["default"].arch() + external_node_os_["default"].totalmem()).digest('hex');
         return machineId;
     }
     flushSync() {
@@ -501,7 +2441,6 @@ class Telemetry {
 function createTelemetry(options) {
     return new Telemetry(options);
 }
-var external_node_path_ = __webpack_require__("node:path");
 const DEFAULT_PERSIST_FILENAME = '.c15t-state.json';
 function getPersistPath(projectRoot) {
     return external_node_path_["default"].join(projectRoot, DEFAULT_PERSIST_FILENAME);
@@ -666,6 +2605,198 @@ function createDebugSubscriber(machineId, logger) {
         }
     };
 }
+var constants = __webpack_require__("./src/constants.ts");
+const ERROR_CATALOG = {
+    AUTH_FAILED: {
+        code: 'AUTH_FAILED',
+        message: 'Authentication failed',
+        hint: 'Try running `c15t login` again',
+        docs: `${constants.tl.CLI_DOCS}/auth`
+    },
+    AUTH_EXPIRED: {
+        code: 'AUTH_EXPIRED',
+        message: 'Session expired',
+        hint: 'Run `c15t login` to refresh your session'
+    },
+    AUTH_NOT_LOGGED_IN: {
+        code: 'AUTH_NOT_LOGGED_IN',
+        message: 'Not logged in',
+        hint: 'Run `c15t login` to authenticate'
+    },
+    AUTH_TOKEN_INVALID: {
+        code: 'AUTH_TOKEN_INVALID',
+        message: 'Invalid authentication token',
+        hint: 'Try logging out with `c15t logout` and logging in again'
+    },
+    DEVICE_FLOW_TIMEOUT: {
+        code: 'DEVICE_FLOW_TIMEOUT',
+        message: 'Authentication timed out',
+        hint: 'The login request expired. Run `c15t login` to try again'
+    },
+    DEVICE_FLOW_DENIED: {
+        code: 'DEVICE_FLOW_DENIED',
+        message: 'Authentication denied',
+        hint: 'The login request was denied. Run `c15t login` to try again'
+    },
+    DEVICE_FLOW_PENDING: {
+        code: 'DEVICE_FLOW_PENDING',
+        message: 'Waiting for authentication',
+        hint: 'Please complete the login in your browser'
+    },
+    NOT_A_PROJECT: {
+        code: 'NOT_A_PROJECT',
+        message: 'No package.json found',
+        hint: 'Make sure you are in a JavaScript/TypeScript project directory'
+    },
+    FRAMEWORK_NOT_DETECTED: {
+        code: 'FRAMEWORK_NOT_DETECTED',
+        message: 'Could not detect framework',
+        hint: 'Supported frameworks: Next.js, React, Remix, Vite',
+        docs: `${constants.tl.CLI_DOCS}/frameworks`
+    },
+    LAYOUT_NOT_FOUND: {
+        code: 'LAYOUT_NOT_FOUND',
+        message: 'Could not find layout file',
+        hint: 'Make sure you have app/layout.tsx or pages/_app.tsx'
+    },
+    CONFIG_EXISTS: {
+        code: 'CONFIG_EXISTS',
+        message: 'c15t configuration already exists',
+        hint: 'Use --force to overwrite existing configuration'
+    },
+    CONFIG_NOT_FOUND: {
+        code: 'CONFIG_NOT_FOUND',
+        message: 'c15t configuration not found',
+        hint: 'Run `c15t generate` to create a configuration'
+    },
+    CONFIG_INVALID: {
+        code: 'CONFIG_INVALID',
+        message: 'Invalid c15t configuration',
+        hint: 'Check your c15t.config.ts file for errors',
+        docs: `${constants.tl.DOCS}/configuration`
+    },
+    NETWORK_ERROR: {
+        code: 'NETWORK_ERROR',
+        message: 'Network request failed',
+        hint: 'Check your internet connection'
+    },
+    CONTROL_PLANE_CONNECTION_FAILED: {
+        code: 'CONTROL_PLANE_CONNECTION_FAILED',
+        message: 'Could not connect to consent.io',
+        hint: `Check if ${constants.tl.CONSENT_IO} is accessible`
+    },
+    API_ERROR: {
+        code: 'API_ERROR',
+        message: 'API request failed',
+        hint: 'Check the error details and try again'
+    },
+    URL_INVALID: {
+        code: 'URL_INVALID',
+        message: 'Invalid URL format',
+        hint: 'Expected format: https://your-instance.c15t.dev'
+    },
+    INSTANCE_NOT_FOUND: {
+        code: 'INSTANCE_NOT_FOUND',
+        message: 'Instance not found',
+        hint: 'Run `c15t instances list` to see available instances'
+    },
+    INSTANCE_NAME_INVALID: {
+        code: 'INSTANCE_NAME_INVALID',
+        message: 'Invalid instance name',
+        hint: 'Instance names must be alphanumeric with hyphens'
+    },
+    FILE_NOT_FOUND: {
+        code: 'FILE_NOT_FOUND',
+        message: 'File not found'
+    },
+    FILE_READ_ERROR: {
+        code: 'FILE_READ_ERROR',
+        message: 'Could not read file',
+        hint: 'Check file permissions'
+    },
+    FILE_WRITE_ERROR: {
+        code: 'FILE_WRITE_ERROR',
+        message: 'Could not write file',
+        hint: 'Check file permissions and disk space'
+    },
+    DIRECTORY_NOT_FOUND: {
+        code: 'DIRECTORY_NOT_FOUND',
+        message: 'Directory not found'
+    },
+    COMMAND_NOT_FOUND: {
+        code: 'COMMAND_NOT_FOUND',
+        message: 'Unknown command',
+        hint: 'Run `c15t --help` to see available commands'
+    },
+    SUBCOMMAND_REQUIRED: {
+        code: 'SUBCOMMAND_REQUIRED',
+        message: 'Subcommand required',
+        hint: 'Run the command with --help to see available subcommands'
+    },
+    FLAG_VALUE_REQUIRED: {
+        code: 'FLAG_VALUE_REQUIRED',
+        message: 'Flag requires a value'
+    },
+    INSTALL_FAILED: {
+        code: 'INSTALL_FAILED',
+        message: 'Package installation failed',
+        hint: 'Try running the install command manually'
+    },
+    PACKAGE_MANAGER_NOT_FOUND: {
+        code: 'PACKAGE_MANAGER_NOT_FOUND',
+        message: 'Could not detect package manager',
+        hint: 'Make sure npm, yarn, pnpm, or bun is installed'
+    },
+    MIGRATION_FAILED: {
+        code: 'MIGRATION_FAILED',
+        message: 'Database migration failed',
+        hint: 'Check the error details and database connection'
+    },
+    MIGRATION_CONFIG_MISSING: {
+        code: 'MIGRATION_CONFIG_MISSING',
+        message: 'Migration configuration missing',
+        hint: 'Make sure your c15t.config.ts includes database configuration'
+    },
+    UNKNOWN_ERROR: {
+        code: 'UNKNOWN_ERROR',
+        message: 'An unexpected error occurred',
+        hint: `Please report this issue at ${constants.tl.GITHUB}/issues`
+    },
+    CANCELLED: {
+        code: 'CANCELLED',
+        message: 'Operation cancelled'
+    }
+};
+class CliError extends Error {
+    code;
+    context;
+    entry;
+    constructor(code, context){
+        const entry = ERROR_CATALOG[code];
+        super(entry.message);
+        this.name = 'CliError';
+        this.code = code;
+        this.context = context;
+        this.entry = entry;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, CliError);
+    }
+    display(logger) {
+        const entry = this.entry;
+        let message = entry.message;
+        if (this.context?.details) message += `: ${this.context.details}`;
+        logger.error(message);
+        if ('hint' in entry && entry.hint) logger.info(`Hint: ${entry.hint}`);
+        if ('docs' in entry && entry.docs) logger.info(`Docs: ${entry.docs}`);
+    }
+    static from(error, fallbackCode = 'UNKNOWN_ERROR') {
+        if (error instanceof CliError) return error;
+        const message = error instanceof Error ? error.message : String(error);
+        return new CliError(fallbackCode, {
+            details: message,
+            originalError: error
+        });
+    }
+}
 async function runPackageManagerInstall(projectRoot, dependencies, packageManager) {
     if (0 === dependencies.length) return;
     let command;
@@ -838,9 +2969,8 @@ const fileGenerationActor = (0, __rspack_external_xstate.fromPromise)(async ({ i
         nextConfigPath: null,
         envPath: null
     };
-    const { projectRoot, framework, cwd, logger } = cliContext;
-    framework.pkg;
-    const { generateFiles } = await __webpack_require__.e("153").then(__webpack_require__.bind(__webpack_require__, "./src/commands/generate/options/utils/generate-files.ts"));
+    const { projectRoot, logger } = cliContext;
+    const { generateFiles } = await __webpack_require__.e("642").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}`),
@@ -868,7 +2998,7 @@ const fileGenerationActor = (0, __rspack_external_xstate.fromPromise)(async ({ i
         }
         const generateResult = await generateFiles({
             context: cliContext,
-            mode: mode,
+            mode,
             spinner: spinnerMock,
             backendURL: backendURL ?? void 0,
             useEnvFile,
@@ -938,29 +3068,6 @@ async function preflight_fileExists(filePath) {
         return false;
     }
 }
-async function checkGitStatus(projectRoot) {
-    try {
-        const gitDir = external_node_path_["default"].join(projectRoot, '.git');
-        const isGitRepo = await preflight_fileExists(gitDir);
-        if (!isGitRepo) return {
-            name: 'Git',
-            status: 'warn',
-            message: 'Not a git repository',
-            hint: 'Consider initializing git to track changes'
-        };
-        return {
-            name: 'Git',
-            status: 'pass',
-            message: 'Git repository detected'
-        };
-    } catch  {
-        return {
-            name: 'Git',
-            status: 'warn',
-            message: 'Could not check git status'
-        };
-    }
-}
 async function runPreflightChecks(context) {
     const { projectRoot, framework, packageManager, logger } = context;
     const checks = [];
@@ -991,16 +3098,6 @@ async function runPreflightChecks(context) {
         message: packageManager.name ? `Using ${packageManager.name}` : 'No package manager detected',
         hint: packageManager.name ? void 0 : 'Will default to npm'
     });
-    const gitCheck = await checkGitStatus(projectRoot);
-    checks.push(gitCheck);
-    const configPath = external_node_path_["default"].join(projectRoot, 'c15t.config.ts');
-    const hasExistingConfig = await preflight_fileExists(configPath);
-    checks.push({
-        name: 'Existing config',
-        status: hasExistingConfig ? 'warn' : 'pass',
-        message: hasExistingConfig ? 'c15t.config.ts already exists' : 'No existing configuration',
-        hint: hasExistingConfig ? 'Existing config will be overwritten' : void 0
-    });
     const hasFailures = checks.some((c)=>'fail' === c.status);
     return {
         passed: !hasFailures,
@@ -1057,14 +3154,248 @@ function displayPreflightFailure(context, checks) {
         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'));
+    lines.push('');
+    lines.push('Please fix the issues above and try again.');
+    logger.message(lines.join('\n'));
+}
+function getControlPlaneBaseUrl() {
+    const envValue = process.env.CONSENT_URL?.trim();
+    if (!envValue) return constants.tl.CONSENT_IO;
+    return envValue.replace(/\/+$/, '');
+}
+var config_store = __webpack_require__("./src/auth/config-store.ts");
+function getEndpoints(baseUrl) {
+    return {
+        deviceCodeV1Endpoint: `${baseUrl}/api/v1/auth/device/code`,
+        deviceTokenV1Endpoint: `${baseUrl}/api/v1/auth/device/token`,
+        deviceAuthorizationEndpoint: `${baseUrl}/oauth/device/code`,
+        tokenEndpoint: `${baseUrl}/oauth/token`
+    };
+}
+function isApiSuccessPayload(payload) {
+    return 'object' == typeof payload && null !== payload && 'success' in payload && true === payload.success && 'data' in payload;
+}
+function normalizeDeviceCodeResponse(payload) {
+    if (payload && 'object' == typeof payload && 'device_code' in payload && 'user_code' in payload && 'verification_uri' in payload) return payload;
+    if (payload && 'object' == typeof payload && 'deviceCode' in payload && 'userCode' in payload && 'verificationUri' in payload) {
+        const v1 = payload;
+        return {
+            device_code: v1.deviceCode,
+            user_code: v1.userCode,
+            verification_uri: v1.verificationUri,
+            verification_uri_complete: v1.verificationUriComplete,
+            expires_in: v1.expiresIn,
+            interval: v1.interval
+        };
+    }
+    throw new CliError('AUTH_FAILED', {
+        details: 'Invalid device code response'
+    });
+}
+function normalizeTokenResponse(payload) {
+    if (payload && 'object' == typeof payload && 'access_token' in payload && 'token_type' in payload) return payload;
+    if (payload && 'object' == typeof payload && 'accessToken' in payload && 'tokenType' in payload) {
+        const v1 = payload;
+        return {
+            access_token: v1.accessToken,
+            token_type: v1.tokenType,
+            expires_in: v1.expiresIn,
+            refresh_token: v1.refreshToken,
+            scope: v1.scope
+        };
+    }
+    throw new CliError('AUTH_FAILED', {
+        details: 'Invalid token response'
+    });
+}
+async function parseJsonSafe(response) {
+    try {
+        return await response.json();
+    } catch  {
+        return null;
+    }
+}
+function toDeviceFlowErrorFromV1(response, payload) {
+    if (!payload || 'object' != typeof payload) return null;
+    const apiError = payload;
+    const errorCode = apiError.error?.code;
+    const details = apiError.error?.details && 'object' == typeof apiError.error.details ? apiError.error.details : void 0;
+    const status = details?.status;
+    if ('authorization_pending' === status) return {
+        error: 'authorization_pending',
+        error_description: apiError.error?.message ?? 'Authorization pending'
+    };
+    if ('used' === status) return {
+        error: 'access_denied',
+        error_description: apiError.error?.message ?? 'Device code already used. Start a new login flow.'
+    };
+    if ('expired' === status || 401 === response.status) return {
+        error: 'expired_token',
+        error_description: apiError.error?.message ?? 'Device code expired'
+    };
+    if (409 === response.status) return {
+        error: 'authorization_pending',
+        error_description: apiError.error?.message ?? 'Authorization pending'
+    };
+    if ('FORBIDDEN' === errorCode || 403 === response.status) return {
+        error: 'access_denied',
+        error_description: apiError.error?.message ?? 'Authorization denied'
+    };
+    return null;
+}
+async function initiateDeviceFlow(baseUrl = constants.tl.CONSENT_IO) {
+    const endpoints = getEndpoints(baseUrl);
+    {
+        const v1Response = await fetch(endpoints.deviceCodeV1Endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: '{}'
+        });
+        if (v1Response.ok) {
+            const payload = await parseJsonSafe(v1Response);
+            const data = isApiSuccessPayload(payload) ? payload.data : payload;
+            return normalizeDeviceCodeResponse(data);
+        }
+        if (404 !== v1Response.status) {
+            const payload = await parseJsonSafe(v1Response);
+            const message = payload && 'object' == typeof payload && 'error' in payload && payload.error?.message ? payload.error?.message : 'Request failed';
+            throw new CliError('AUTH_FAILED', {
+                details: `Device authorization failed: ${v1Response.status} ${message}`
+            });
+        }
+    }
+    const response = await fetch(endpoints.deviceAuthorizationEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams({
+            client_id: 'c15t-cli',
+            scope: 'instances:read instances:write'
+        })
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new CliError('AUTH_FAILED', {
+            details: `Device authorization failed: ${response.status} ${text}`
+        });
+    }
+    const payload = await parseJsonSafe(response);
+    const data = normalizeDeviceCodeResponse(payload);
+    if (!data.device_code || !data.user_code || !data.verification_uri) throw new CliError('AUTH_FAILED', {
+        details: 'Invalid device code response'
+    });
+    return data;
+}
+async function pollForToken(baseUrl, deviceCode, interval = constants.fT.DEVICE_FLOW_POLL_INTERVAL, expiresIn = constants.fT.DEVICE_FLOW_EXPIRY) {
+    const endpoints = getEndpoints(baseUrl);
+    const startTime = Date.now();
+    const expiryTime = startTime + 1000 * expiresIn;
+    let currentInterval = 1000 * interval;
+    let useLegacyOAuthEndpoints = false;
+    while(Date.now() < expiryTime){
+        await sleep(currentInterval);
+        try {
+            if (!useLegacyOAuthEndpoints) {
+                const v1Response = await fetch(endpoints.deviceTokenV1Endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        deviceCode
+                    })
+                });
+                if (v1Response.ok) {
+                    const payload = await parseJsonSafe(v1Response);
+                    const data = isApiSuccessPayload(payload) ? payload.data : payload;
+                    return normalizeTokenResponse(data);
+                }
+                if (404 === v1Response.status) useLegacyOAuthEndpoints = true;
+                else {
+                    const payload = await parseJsonSafe(v1Response);
+                    const mappedError = toDeviceFlowErrorFromV1(v1Response, payload);
+                    if (mappedError) switch(mappedError.error){
+                        case 'authorization_pending':
+                            continue;
+                        case 'expired_token':
+                            throw new CliError('DEVICE_FLOW_TIMEOUT', {
+                                details: mappedError.error_description
+                            });
+                        case 'access_denied':
+                            throw new CliError('DEVICE_FLOW_DENIED', {
+                                details: mappedError.error_description
+                            });
+                    }
+                    const message = payload && 'object' == typeof payload && 'error' in payload && payload.error?.message ? payload.error?.message : 'Request failed';
+                    throw new CliError('AUTH_FAILED', {
+                        details: `Token request failed: ${v1Response.status} ${message}`
+                    });
+                }
+            }
+            const response = await fetch(endpoints.tokenEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                },
+                body: new URLSearchParams({
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    device_code: deviceCode,
+                    client_id: 'c15t-cli'
+                })
+            });
+            if (response.ok) {
+                const payload = await parseJsonSafe(response);
+                const token = normalizeTokenResponse(payload);
+                return token;
+            }
+            const payload = await parseJsonSafe(response);
+            const error = payload;
+            switch(error.error){
+                case 'authorization_pending':
+                    continue;
+                case 'slow_down':
+                    currentInterval += 5000;
+                    continue;
+                case 'access_denied':
+                    throw new CliError('DEVICE_FLOW_DENIED', {
+                        details: error.error_description
+                    });
+                case 'expired_token':
+                    throw new CliError('DEVICE_FLOW_TIMEOUT', {
+                        details: 'The device code has expired'
+                    });
+                default:
+                    throw new CliError('AUTH_FAILED', {
+                        details: error.error_description || `Unknown error: ${error.error}`
+                    });
+            }
+        } catch (error) {
+            if (error instanceof CliError) throw error;
+        }
+    }
+    throw new CliError('DEVICE_FLOW_TIMEOUT');
+}
+function formatUserCode(userCode) {
+    if (userCode.includes('-')) return userCode;
+    const midpoint = Math.ceil(userCode.length / 2);
+    return `${userCode.slice(0, midpoint)}-${userCode.slice(midpoint)}`;
+}
+function getVerificationUrl(response) {
+    if (response.verification_uri_complete) return response.verification_uri_complete;
+    const url = new URL(response.verification_uri);
+    url.searchParams.set('user_code', response.user_code);
+    return url.toString();
+}
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
 }
 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');
+    context.logger.info('Learn more: https://v2.c15t.com/docs/dev-tools/overview');
     const enableDevTools = await prompts_.select({
         message: 'Install and enable c15t DevTools?',
         options: [
@@ -1095,7 +3426,7 @@ 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');
+    context.logger.info('Learn more: https://v2.c15t.com/docs/frameworks/nextjs/ssr');
     const enableSSR = await prompts_.select({
         message: 'Enable SSR consent prefetch? (faster first banner visibility, dynamic route)',
         options: [
@@ -1122,6 +3453,205 @@ async function getSSROption({ context, handleCancel, onCancel }) {
     }
     return enableSSR;
 }
+function extractAwsRegion(value) {
+    if (!value) return;
+    const match = value.match(/[a-z]{2}-[a-z]+-\d/);
+    return match?.[0];
+}
+function client_isApiSuccessPayload(payload) {
+    return 'object' == typeof payload && null !== payload && 'success' in payload && true === payload.success && 'data' in payload;
+}
+async function client_parseJsonSafe(response) {
+    try {
+        return await response.json();
+    } catch  {
+        return null;
+    }
+}
+function mapControlPlaneInstance(raw) {
+    const regionFromObject = 'string' == typeof raw.region ? raw.region : raw.region?.id ?? raw.region?.slug ?? raw.region?.code;
+    const region = regionFromObject ?? raw.regionId ?? raw.regionSlug ?? extractAwsRegion(raw.backendURL) ?? extractAwsRegion(raw.dashboardURL);
+    return {
+        id: raw.instanceId,
+        name: raw.instanceName,
+        organizationSlug: raw.organizationSlug,
+        region,
+        url: raw.backendURL ?? raw.dashboardURL ?? '',
+        createdAt: new Date(0).toISOString(),
+        status: raw.backendURL ? 'active' : 'pending'
+    };
+}
+class ControlPlaneClient {
+    config;
+    connected = false;
+    constructor(config){
+        this.config = {
+            clientName: constants.Aw.CONTROL_PLANE_CLIENT_NAME,
+            clientVersion: constants.Aw.VERSION,
+            timeout: constants.fT.CONTROL_PLANE_CONNECTION,
+            ...config
+        };
+    }
+    async connect() {
+        this.connected = true;
+        return {
+            connected: true,
+            capabilities: {
+                tools: [
+                    'listInstances',
+                    'createInstance',
+                    'getInstance'
+                ]
+            }
+        };
+    }
+    async close() {
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    ensureConnected() {
+        if (!this.connected) throw new CliError('CONTROL_PLANE_CONNECTION_FAILED', {
+            details: 'Not connected to control plane'
+        });
+    }
+    buildUrl(path) {
+        return `${this.config.baseUrl}/api/v1${path}`;
+    }
+    async request(path, init) {
+        this.ensureConnected();
+        const response = await fetch(this.buildUrl(path), {
+            method: init?.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${this.config.accessToken}`,
+                'Content-Type': 'application/json'
+            },
+            body: init?.body === void 0 ? void 0 : JSON.stringify(init.body)
+        });
+        const payload = await client_parseJsonSafe(response);
+        if (response.ok && client_isApiSuccessPayload(payload)) return payload.data;
+        const apiError = payload;
+        const errorCode = apiError?.error?.code;
+        const errorMessage = apiError?.error?.message ?? 'Request failed';
+        if (401 === response.status) throw new CliError('AUTH_TOKEN_INVALID', {
+            details: `${response.status} ${errorMessage}`
+        });
+        throw new CliError('API_ERROR', {
+            details: `${response.status} ${errorCode ? `${errorCode}: ` : ''}${errorMessage}`
+        });
+    }
+    async listOrganizations() {
+        return this.request('/consent/organizations');
+    }
+    async listRegions() {
+        return this.request('/consent/regions');
+    }
+    async listInstances() {
+        const raw = await this.request('/consent/instances');
+        return raw.map(mapControlPlaneInstance);
+    }
+    async getInstance(id) {
+        const instances = await this.listInstances();
+        const instance = instances.find((item)=>item.id === id);
+        if (!instance) throw new CliError('INSTANCE_NOT_FOUND', {
+            details: `Instance not found: ${id}`
+        });
+        return instance;
+    }
+    async createInstance(request) {
+        const { organizationSlug, region, trustedOrigins } = request.config;
+        if (!organizationSlug || !region) throw new CliError('API_ERROR', {
+            details: 'organizationSlug and region are required'
+        });
+        const instance = await this.request('/consent/instances', {
+            method: 'POST',
+            body: {
+                organizationSlug,
+                name: request.name,
+                region,
+                production: false,
+                trustedOrigins: trustedOrigins ?? [],
+                useV2: true
+            }
+        });
+        return mapControlPlaneInstance(instance);
+    }
+    async deleteInstance(id) {
+        await this.request(`/consent/instances/${encodeURIComponent(id)}`, {
+            method: 'DELETE'
+        });
+    }
+}
+async function createControlPlaneClient(accessToken, baseUrl = constants.tl.CONSENT_IO) {
+    const client = new ControlPlaneClient({
+        baseUrl,
+        accessToken
+    });
+    const state = await client.connect();
+    if (!state.connected) throw new CliError('CONTROL_PLANE_CONNECTION_FAILED', {
+        details: state.error
+    });
+    return client;
+}
+async function createControlPlaneClientFromConfig(baseUrl = constants.tl.CONSENT_IO) {
+    const { getAccessToken } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/auth/config-store.ts"));
+    const accessToken = await getAccessToken();
+    if (!accessToken) return null;
+    return createControlPlaneClient(accessToken, baseUrl);
+}
+external_picocolors_["default"].green, external_picocolors_["default"].red, external_picocolors_["default"].yellow, external_picocolors_["default"].blue, external_picocolors_["default"].dim, external_picocolors_["default"].cyan, external_picocolors_["default"].bold, external_picocolors_["default"].underline;
+function createTaskSpinner(initialMessage) {
+    const spinner = prompts_.spinner();
+    let isRunning = false;
+    return {
+        start (message) {
+            if (!isRunning) {
+                spinner.start(message || initialMessage || 'Processing...');
+                isRunning = true;
+            }
+        },
+        stop (message) {
+            if (isRunning) {
+                spinner.stop(message || 'Done');
+                isRunning = false;
+            }
+        },
+        message (message) {
+            if (isRunning) spinner.message(message);
+        },
+        success (message) {
+            if (isRunning) {
+                spinner.stop(external_picocolors_["default"].green('✓') + ' ' + message);
+                isRunning = false;
+            }
+        },
+        error (message) {
+            if (isRunning) {
+                spinner.stop(external_picocolors_["default"].red('✗') + ' ' + message);
+                isRunning = false;
+            }
+        }
+    };
+}
+function isValidUrl(value) {
+    return constants.QL.URL.test(value);
+}
+function isValidC15tUrl(value) {
+    return constants.QL.C15T_URL.test(value);
+}
+function isValidInstanceName(value) {
+    return /^[a-z][a-z0-9-]{2,62}$/.test(value) && !value.includes('--');
+}
+function createValidator(validate, errorMessage) {
+    return (value)=>{
+        if (!validate(value)) return errorMessage;
+    };
+}
+createValidator(isValidUrl, 'Please enter a valid URL (e.g., https://example.com)');
+createValidator(isValidC15tUrl, 'Please enter a valid c15t URL (e.g., https://my-app.c15t.dev)');
+const validateInstanceName = createValidator(isValidInstanceName, 'Instance name must be 3-63 lowercase alphanumeric characters with hyphens');
+createValidator((value)=>value.trim().length > 0, 'This field is required');
 function isCancel(value) {
     return prompts_.isCancel(value);
 }
@@ -1131,29 +3661,37 @@ class PromptCancelledError extends Error {
         this.name = 'PromptCancelledError';
     }
 }
+function formatInstanceLabel(instance) {
+    if (instance.organizationSlug) return `${instance.organizationSlug}/${instance.name}`;
+    return instance.name;
+}
+function formatInstanceRegion(instance) {
+    return `(${instance.region ?? 'unknown'})`;
+}
+function isV2ModeEnabled() {
+    return '1' === process.env[constants.h3.V2];
+}
 const modeSelectionActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
+    let initialMode = input.initialMode;
+    if ('c15t' === initialMode || 'self-hosted' === initialMode) initialMode = 'hosted';
+    if (void 0 === initialMode) initialMode = 'hosted';
     const result = await prompts_.select({
         message: 'How would you like to store consent decisions?',
-        initialValue: input.initialMode ?? 'c15t',
+        initialValue: initialMode,
         options: [
             {
-                value: 'c15t',
-                label: 'Hosted c15t (consent.io)',
-                hint: 'Recommended: Fully managed service'
+                value: 'hosted',
+                label: 'Hosted',
+                hint: 'consent.io or self-hosted backend URL'
             },
             {
                 value: 'offline',
-                label: 'Offline Mode',
+                label: 'Offline',
                 hint: 'Store in browser, no backend needed'
             },
-            {
-                value: 'self-hosted',
-                label: 'Self-Hosted',
-                hint: 'Run your own c15t backend'
-            },
             {
                 value: 'custom',
-                label: 'Custom Implementation',
+                label: 'Custom',
                 hint: 'Full control over storage logic'
             }
         ]
@@ -1163,61 +3701,272 @@ const modeSelectionActor = (0, __rspack_external_xstate.fromPromise)(async ({ in
         mode: result
     };
 });
-const accountCreationActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { cliContext } = input;
-    const needsAccount = await prompts_.confirm({
-        message: 'Do you need to create a consent.io account?',
-        initialValue: true
-    });
-    if (isCancel(needsAccount)) throw new PromptCancelledError('account_creation');
-    if (!needsAccount) return {
-        needsAccount: false,
-        browserOpened: false
-    };
-    prompts_.note(`We'll open your browser to create a consent.io account and set up your instance.\nFollow these steps:\n1. Sign up for a consent.io account\n2. Create a new instance in the dashboard\n3. Configure your trusted origins (domains that can connect)\n4. Copy the provided backendURL (e.g., https://your-instance.c15t.dev)`, 'consent.io Setup');
-    const shouldOpen = await prompts_.confirm({
-        message: 'Open browser to sign up for consent.io?',
-        initialValue: true
-    });
-    if (isCancel(shouldOpen)) throw new PromptCancelledError('browser_open');
-    let browserOpened = false;
-    if (shouldOpen) try {
-        const open = (await import("open")).default;
-        await open('https://consent.io/dashboard/register?ref=cli');
-        browserOpened = true;
-        const enterPressed = await prompts_.text({
-            message: 'Press Enter once you have created your instance and have the backendURL'
-        });
-        if (isCancel(enterPressed)) throw new PromptCancelledError('url_input_wait');
-    } catch (error) {
-        if (error instanceof PromptCancelledError) throw error;
-        cliContext.logger.warn('Failed to open browser automatically. Please visit https://consent.io/dashboard/register manually.');
-    }
-    return {
-        needsAccount: true,
-        browserOpened
-    };
-});
-const backendURLActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
-    const { initialURL, isC15tMode } = input;
-    const placeholder = isC15tMode ? 'https://your-instance.c15t.dev' : 'https://your-backend.example.com/api/c15t';
+async function promptBackendURL(input) {
     const result = await prompts_.text({
-        message: isC15tMode ? 'Enter your consent.io instance URL:' : 'Enter your self-hosted backend URL:',
-        placeholder,
-        initialValue: initialURL,
+        message: input.message,
+        placeholder: input.placeholder,
+        initialValue: input.initialURL,
         validate: (value)=>{
-            if (!value || '' === value) return 'URL is required';
+            if (!value || '' === value.trim()) return 'URL is required';
             try {
-                const url = new URL(value);
-                if (isC15tMode && !url.hostname.endsWith('.c15t.dev')) return 'Please enter a valid *.c15t.dev URL';
+                new URL(value);
             } catch  {
                 return 'Please enter a valid URL';
             }
         }
     });
-    if (isCancel(result)) throw new PromptCancelledError('backend_url');
+    if (isCancel(result)) throw new PromptCancelledError(input.stage);
+    return result;
+}
+async function runConsentLogin(cliContext) {
+    const baseUrl = getControlPlaneBaseUrl();
+    const authState = await (0, config_store.IM)();
+    let useExistingSession = false;
+    if (authState.isLoggedIn && !authState.isExpired) {
+        const keepCurrentSession = await prompts_.confirm({
+            message: 'You are already signed in. Use your existing session?',
+            initialValue: true
+        });
+        if (isCancel(keepCurrentSession)) throw new PromptCancelledError('consent_existing_session');
+        if (keepCurrentSession) useExistingSession = true;
+    }
+    if (useExistingSession) return;
+    const deviceSpinner = createTaskSpinner('Requesting device code...');
+    deviceSpinner.start();
+    try {
+        const deviceCode = await initiateDeviceFlow(baseUrl);
+        deviceSpinner.success('Device code received');
+        const userCode = formatUserCode(deviceCode.user_code);
+        const verificationUrl = getVerificationUrl(deviceCode);
+        cliContext.logger.message('');
+        cliContext.logger.note(`Your code: ${external_picocolors_["default"].bold(external_picocolors_["default"].cyan(userCode))}\n\nThis code will expire in ${Math.floor(deviceCode.expires_in / 60)} minutes.`, 'Verification Code');
+        cliContext.logger.message('');
+        cliContext.logger.message(`Open this URL to continue: ${external_picocolors_["default"].underline(verificationUrl)}`);
+        cliContext.logger.message('');
+        const shouldOpen = await prompts_.confirm({
+            message: 'Open the verification page in your browser?',
+            initialValue: true
+        });
+        if (isCancel(shouldOpen)) throw new PromptCancelledError('consent_open_verification');
+        if (shouldOpen) try {
+            const open = (await import("open")).default;
+            await open(verificationUrl);
+        } catch  {
+            cliContext.logger.warn(`Could not open browser automatically. Visit ${verificationUrl} manually.`);
+        }
+        const authSpinner = createTaskSpinner('Waiting for authorization...');
+        authSpinner.start();
+        try {
+            const token = await pollForToken(baseUrl, deviceCode.device_code, deviceCode.interval, deviceCode.expires_in);
+            authSpinner.success('Authorization received');
+            await (0, config_store.Ex)(token.access_token, {
+                refreshToken: token.refresh_token,
+                expiresIn: token.expires_in
+            });
+        } catch (error) {
+            authSpinner.error('Authorization failed');
+            throw error;
+        }
+    } catch (error) {
+        deviceSpinner.stop();
+        throw error;
+    }
+}
+async function createInstanceInteractively(client, cliContext) {
+    const preloadSpinner = createTaskSpinner('Loading organizations and regions...');
+    preloadSpinner.start();
+    let organizations;
+    let regions;
+    try {
+        [organizations, regions] = await Promise.all([
+            client.listOrganizations(),
+            client.listRegions()
+        ]);
+    } finally{
+        preloadSpinner.stop();
+    }
+    if (0 === organizations.length) throw new CliError('API_ERROR', {
+        details: 'No organizations available for this account'
+    });
+    if (0 === regions.length) throw new CliError('API_ERROR', {
+        details: 'No provisioning regions available'
+    });
+    const orgSelection = await prompts_.select({
+        message: 'Select organization:',
+        options: organizations.map((org)=>({
+                value: org.organizationSlug,
+                label: org.organizationName,
+                hint: `${org.organizationSlug} • ${org.role}`
+            })),
+        initialValue: organizations[0]?.organizationSlug
+    });
+    if (isCancel(orgSelection)) throw new PromptCancelledError('instance_create_org_slug');
+    const v2Regions = regions.filter((region)=>'v2' === region.family);
+    if (0 === v2Regions.length) throw new CliError('API_ERROR', {
+        details: 'No v2 provisioning regions available'
+    });
+    const regionSelection = await prompts_.select({
+        message: 'Select V2 region:',
+        options: v2Regions.map((region)=>({
+                value: region.id,
+                label: region.id,
+                hint: region.label
+            })),
+        initialValue: v2Regions.find((region)=>'us-east-1' === region.id)?.id
+    });
+    if (isCancel(regionSelection)) throw new PromptCancelledError('instance_create_region');
+    const slugInput = await prompts_.text({
+        message: 'New instance slug:',
+        placeholder: 'my-app',
+        validate: (value)=>validateInstanceName(value.trim())
+    });
+    if (isCancel(slugInput)) throw new PromptCancelledError('instance_create_name');
+    const slug = slugInput.trim();
+    const createSpinner = createTaskSpinner(`Creating instance "${slug}"...`);
+    createSpinner.start();
+    try {
+        const instance = await client.createInstance({
+            name: slug,
+            config: {
+                organizationSlug: orgSelection,
+                region: regionSelection
+            }
+        });
+        createSpinner.success('Instance created');
+        cliContext.logger.info('Created as a v2 development instance. Enable production mode in the dashboard when you are ready.');
+        return instance;
+    } catch (error) {
+        createSpinner.error('Failed to create instance');
+        throw error;
+    }
+}
+async function selectOrCreateInstance(cliContext) {
+    const baseUrl = getControlPlaneBaseUrl();
+    const listSpinner = createTaskSpinner('Fetching your consent.io instances...');
+    listSpinner.start();
+    const client = await createControlPlaneClientFromConfig(baseUrl);
+    if (!client) {
+        listSpinner.stop();
+        throw new CliError('AUTH_NOT_LOGGED_IN');
+    }
+    try {
+        const instances = await client.listInstances();
+        listSpinner.stop();
+        if (0 === instances.length) {
+            cliContext.logger.info('No instances found. Creating a new instance for this project.');
+            return await createInstanceInteractively(client, cliContext);
+        }
+        const selectedId = await prompts_.select({
+            message: 'Select an instance to use:',
+            options: [
+                ...instances.map((instance)=>({
+                        value: instance.id,
+                        label: formatInstanceLabel(instance),
+                        hint: formatInstanceRegion(instance)
+                    })),
+                {
+                    value: '__create__',
+                    label: 'Create new instance',
+                    hint: 'Provision a new consent.io instance now'
+                }
+            ]
+        });
+        if (isCancel(selectedId)) throw new PromptCancelledError('instance_select');
+        if ('__create__' === selectedId) return await createInstanceInteractively(client, cliContext);
+        const selected = instances.find((instance)=>instance.id === selectedId);
+        if (!selected) throw new CliError('INSTANCE_NOT_FOUND');
+        return selected;
+    } catch (error) {
+        listSpinner.stop();
+        throw error;
+    } finally{
+        await client.close();
+    }
+}
+const hostedModeActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
+    const { cliContext, initialURL, preselectedProvider } = input;
+    let provider = preselectedProvider ?? null;
+    if (!provider) {
+        const providerSelection = await prompts_.select({
+            message: 'Choose your hosted backend option:',
+            options: [
+                {
+                    value: 'consent.io',
+                    label: 'consent.io (Recommended)',
+                    hint: 'Managed infrastucture'
+                },
+                {
+                    value: 'self-hosted',
+                    label: 'Self-hosted',
+                    hint: 'Use your own deployed c15t backend'
+                }
+            ],
+            initialValue: 'consent.io'
+        });
+        if (isCancel(providerSelection)) throw new PromptCancelledError('hosted_provider');
+        provider = providerSelection;
+    }
+    if ('self-hosted' === provider) {
+        const url = await promptBackendURL({
+            message: 'Enter your self-hosted backend URL:',
+            placeholder: 'https://your-backend.example.com/api/c15t',
+            initialURL,
+            stage: 'self_hosted_backend_url'
+        });
+        return {
+            url,
+            provider
+        };
+    }
+    if (!isV2ModeEnabled()) {
+        cliContext.logger.info('consent.io sign-in is currently disabled. Set V2=1 to enable sign-in and instance selection.');
+        const url = await promptBackendURL({
+            message: 'Enter your consent.io instance URL:',
+            placeholder: 'https://your-instance.c15t.dev',
+            initialURL,
+            stage: 'consent_manual_url'
+        });
+        return {
+            url,
+            provider: 'consent.io'
+        };
+    }
+    const setupMethod = await prompts_.select({
+        message: 'How do you want to configure consent.io?',
+        options: [
+            {
+                value: 'sign-in',
+                label: 'Sign in and pick an instance',
+                hint: 'List existing instances or create a new one'
+            },
+            {
+                value: 'manual-url',
+                label: 'Enter instance URL manually',
+                hint: 'Use an existing backend URL'
+            }
+        ],
+        initialValue: 'sign-in'
+    });
+    if (isCancel(setupMethod)) throw new PromptCancelledError('consent_setup_method');
+    if ('manual-url' === setupMethod) {
+        const url = await promptBackendURL({
+            message: 'Enter your consent.io instance URL:',
+            placeholder: 'https://your-instance.c15t.dev',
+            initialURL,
+            stage: 'consent_manual_url'
+        });
+        return {
+            url,
+            provider: 'consent.io'
+        };
+    }
+    await runConsentLogin(cliContext);
+    const instance = await selectOrCreateInstance(cliContext);
+    await (0, config_store._g)(instance.id);
+    cliContext.logger.info(`Using instance ${external_picocolors_["default"].cyan(instance.name)} (${external_picocolors_["default"].dim(instance.id)})`);
     return {
-        url: result
+        url: instance.url,
+        provider: 'consent.io'
     };
 });
 const backendOptionsActor = (0, __rspack_external_xstate.fromPromise)(async ({ input })=>{
@@ -1268,7 +4017,7 @@ const frontendOptionsActor = (0, __rspack_external_xstate.fromPromise)(async ({
             });
         }
         cliContext.logger.info('Choose how you want your consent UI components generated.');
-        cliContext.logger.info('Learn more: https://c15t.com/docs/frameworks/nextjs/customization');
+        cliContext.logger.info('Learn more: https://v2.c15t.com/docs/frameworks/nextjs/customization');
         const styleResult = await prompts_.select({
             message: 'UI component style:',
             options: [
@@ -1543,8 +4292,8 @@ function preflightFailed({ context }) {
 function hasModeArg({ context }) {
     return null !== context.modeArg;
 }
-function guards_isC15tMode({ context }) {
-    return 'c15t' === context.selectedMode;
+function isHostedMode({ context }) {
+    return 'hosted' === context.selectedMode || 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode;
 }
 function isOfflineMode({ context }) {
     return 'offline' === context.selectedMode;
@@ -1556,7 +4305,7 @@ function isCustomMode({ context }) {
     return 'custom' === context.selectedMode;
 }
 function modeRequiresBackend({ context }) {
-    return 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode;
+    return 'hosted' === context.selectedMode || 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode;
 }
 function modeNoBackend({ context }) {
     return 'offline' === context.selectedMode || 'custom' === context.selectedMode;
@@ -1601,7 +4350,9 @@ 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);
+    return context.framework?.pkg === '@c15t/nextjs' && modeRequiresBackend({
+        context
+    });
 }
 function shouldPromptUIStyle({ context }) {
     return context.framework?.pkg === '@c15t/nextjs' || context.framework?.pkg === '@c15t/react';
@@ -1610,7 +4361,7 @@ const guards = {
     preflightPassed,
     preflightFailed,
     hasModeArg,
-    isC15tMode: guards_isC15tMode,
+    isHostedMode,
     isOfflineMode,
     isSelfHostedMode,
     isCustomMode,
@@ -1642,6 +4393,7 @@ function createInitialContext(cliContext, modeArg) {
         preflightChecks: [],
         selectedMode: null,
         modeArg: modeArg ?? null,
+        hostedProvider: null,
         backendURL: null,
         useEnvFile: true,
         proxyNextjs: true,
@@ -1665,6 +4417,15 @@ function createInitialContext(cliContext, modeArg) {
         stateHistory: []
     };
 }
+function normalizeSelectedMode(mode) {
+    if ('c15t' === mode || 'self-hosted' === mode) return 'hosted';
+    return mode ?? null;
+}
+function getHostedProviderFromMode(mode) {
+    if ('self-hosted' === mode) return 'self-hosted';
+    if ('c15t' === mode) return 'consent.io';
+    return null;
+}
 const generateMachine = (0, __rspack_external_xstate.setup)({
     types: {
         context: {},
@@ -1675,8 +4436,7 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
     actors: {
         preflight: preflightActor,
         modeSelection: modeSelectionActor,
-        accountCreation: accountCreationActor,
-        backendURL: backendURLActor,
+        hostedMode: hostedModeActor,
         backendOptions: backendOptionsActor,
         frontendOptions: frontendOptionsActor,
         scriptsOption: scriptsOptionActor,
@@ -1776,7 +4536,8 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
                     guard: 'hasModeArg',
                     target: 'routeToMode',
                     actions: (0, __rspack_external_xstate.assign)({
-                        selectedMode: ({ context })=>context.modeArg
+                        selectedMode: ({ context })=>normalizeSelectedMode(context.modeArg),
+                        hostedProvider: ({ context })=>getHostedProviderFromMode(context.modeArg)
                     })
                 }
             ],
@@ -1786,7 +4547,8 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
                 onDone: {
                     target: 'routeToMode',
                     actions: (0, __rspack_external_xstate.assign)({
-                        selectedMode: ({ event })=>event.output.mode
+                        selectedMode: ({ event })=>normalizeSelectedMode(event.output.mode),
+                        hostedProvider: null
                     })
                 },
                 onError: {
@@ -1800,17 +4562,13 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
         routeToMode: {
             always: [
                 {
-                    guard: 'isC15tMode',
-                    target: 'c15tMode'
+                    guard: 'isHostedMode',
+                    target: 'hostedMode'
                 },
                 {
                     guard: 'isOfflineMode',
                     target: 'offlineMode'
                 },
-                {
-                    guard: 'isSelfHostedMode',
-                    target: 'selfHostedMode'
-                },
                 {
                     guard: 'isCustomMode',
                     target: 'customMode'
@@ -1820,69 +4578,48 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
                 }
             ]
         },
-        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: {
+        hostedMode: {
             invoke: {
-                src: 'backendURL',
-                input: ()=>({
-                        isC15tMode: false
+                src: 'hostedMode',
+                input: ({ context })=>({
+                        cliContext: context.cliContext,
+                        initialURL: context.backendURL ?? void 0,
+                        preselectedProvider: context.hostedProvider
                     }),
                 onDone: {
                     target: 'backendOptions',
                     actions: (0, __rspack_external_xstate.assign)({
-                        backendURL: ({ event })=>event.output.url
+                        backendURL: ({ event })=>event.output.url,
+                        hostedProvider: ({ event })=>event.output.provider
                     })
                 },
-                onError: {
-                    target: 'cancelling',
-                    actions: (0, __rspack_external_xstate.assign)({
-                        cancelReason: 'Backend URL entry cancelled'
-                    })
-                }
+                onError: [
+                    {
+                        guard: ({ event })=>event.error instanceof PromptCancelledError,
+                        target: 'cancelling',
+                        actions: (0, __rspack_external_xstate.assign)({
+                            cancelReason: 'Hosted setup cancelled'
+                        })
+                    },
+                    {
+                        target: 'error',
+                        actions: (0, __rspack_external_xstate.assign)({
+                            errors: ({ context, event })=>[
+                                    ...context.errors,
+                                    {
+                                        state: 'hostedMode',
+                                        error: event.error,
+                                        timestamp: Date.now()
+                                    }
+                                ]
+                        })
+                    }
+                ]
             }
         },
+        offlineMode: {
+            always: 'frontendOptions'
+        },
         customMode: {
             always: 'frontendOptions'
         },
@@ -1913,7 +4650,7 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
                 src: 'frontendOptions',
                 input: ({ context })=>({
                         cliContext: context.cliContext,
-                        hasBackend: 'c15t' === context.selectedMode || 'self-hosted' === context.selectedMode
+                        hasBackend: 'hosted' === context.selectedMode
                     }),
                 onDone: {
                     target: "scriptsOptions",
@@ -2079,9 +4816,9 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
             entry: ({ context })=>{
                 if (!context.cliContext) return;
                 const { logger, packageManager } = context.cliContext;
-                if ('self-hosted' === context.selectedMode) {
+                if ('hosted' === context.selectedMode && 'self-hosted' === context.hostedProvider) {
                     logger.info('Setup your backend with the c15t docs:');
-                    logger.info('https://c15t.com/docs/self-host/v2');
+                    logger.info('https://v2.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) {
@@ -2127,7 +4864,9 @@ const generateMachine = (0, __rspack_external_xstate.setup)({
         error: {
             entry: ({ context })=>{
                 const lastError = context.errors[context.errors.length - 1];
-                context.cliContext?.logger.error(`Error: ${lastError?.error?.message ?? 'Unknown error'}`);
+                const error = lastError?.error;
+                const details = error instanceof CliError && 'string' == typeof error.context?.details ? error.context.details : void 0;
+                context.cliContext?.logger.error(`Error: ${error?.message ?? 'Unknown error'}${details ? `: ${details}` : ''}`);
             },
             always: [
                 {
@@ -2232,7 +4971,7 @@ async function runGenerateMachine(options) {
                 const finalState = String(finalSnapshot.value);
                 const duration = Date.now() - startTime;
                 clearSnapshot(persistPath).catch(()=>{});
-                const success = 'complete' === finalState || 'done' === finalSnapshot.status;
+                const success = 'complete' === finalState;
                 telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
                     success,
                     selectedMode: finalContext.selectedMode ?? void 0,
@@ -2251,9 +4990,14 @@ async function runGenerateMachine(options) {
         });
     });
 }
+function normalizeModeArg(mode) {
+    if (!mode || mode.startsWith('-')) return;
+    const validModes = new Set(Object.values(constants.$V));
+    return validModes.has(mode) ? mode : void 0;
+}
 async function generateAction(context) {
     const { logger, commandArgs, flags } = context;
-    const modeArg = commandArgs[0];
+    const modeArg = normalizeModeArg(commandArgs[0]);
     const resume = true === flags.resume;
     const debug = true === flags.debug || 'debug' === flags.logger;
     logger.debug('Starting generate command with state machine...');
@@ -2269,6 +5013,7 @@ async function generateAction(context) {
         });
         if (!result.success) {
             if (result.errors.length > 0) process.exitCode = 1;
+            return;
         }
     } catch (error) {
         logger.error(`Generate command failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -2390,7 +5135,6 @@ async function installDependencies({ context, dependenciesToAdd, handleCancel, a
         };
     }
 }
-var promises_ = __webpack_require__("node:fs/promises");
 const ADAPTER_LABELS = {
     kyselyAdapter: 'kysely',
     drizzleAdapter: 'drizzle',
@@ -2823,16 +5567,10 @@ async function migrate(context) {
     else await handleMigrationResult(context, result);
 }
 const subcommands = [
-    {
-        name: 'generate',
-        label: 'Generate',
-        hint: 'Generate code for your c15t project',
-        action: generate
-    },
     {
         name: 'migrate',
-        label: 'Migrate',
-        hint: 'Run database migrations',
+        label: 'Migrate database',
+        hint: 'Run latest database migrations',
         action: migrate
     }
 ];
@@ -2843,15 +5581,13 @@ async function selfHost(context) {
     const [subcommand] = commandArgs;
     if (subcommand) {
         switch(subcommand){
-            case 'generate':
-                await generate(context, 'self-hosted');
-                break;
             case 'migrate':
                 await migrate(context);
                 break;
             default:
                 logger.error(`Unknown self-host subcommand: ${subcommand}`);
-                logger.info('Available subcommands: generate, migrate');
+                logger.info('Available subcommands: migrate');
+                logger.info('Usage: c15t self-host <migrate>');
                 telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
                     success: false,
                     reason: 'unknown_subcommand'
@@ -2872,16 +5608,16 @@ async function selfHost(context) {
     promptOptions.push({
         value: 'exit',
         label: 'Exit',
-        hint: 'Return to main menu'
+        hint: 'Close the CLI'
     });
     const selectedSubcommandName = await prompts_.select({
-        message: (0, utils_logger.$e)('info', 'Which self-host command would you like to run?'),
+        message: (0, utils_logger.$e)('info', 'Which self-host task would you like to run?'),
         options: promptOptions
     });
-    if (prompts_.isCancel(selectedSubcommandName) || 'exit' === selectedSubcommandName) {
-        logger.debug('Interactive selection cancelled or exit chosen.');
+    if (prompts_.isCancel(selectedSubcommandName)) {
+        logger.debug('Self-host interactive selection cancelled.');
         telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-            action: prompts_.isCancel(selectedSubcommandName) ? 'cancelled' : 'exit',
+            action: 'cancelled',
             context: 'self-host'
         });
         error.handleCancel('Operation cancelled.', {
@@ -2890,11 +5626,19 @@ async function selfHost(context) {
         });
         return;
     }
+    if ('exit' === selectedSubcommandName) {
+        logger.debug('Self-host interactive selection exited.');
+        telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
+            action: 'exit',
+            context: 'self-host'
+        });
+        logger.outro('Exited self-host menu.');
+        return;
+    }
     const selectedSubcommand = subcommands.find((cmd)=>cmd.name === selectedSubcommandName);
     if (selectedSubcommand) {
         logger.debug(`User selected subcommand: ${selectedSubcommand.name}`);
-        if ('generate' === selectedSubcommand.name) await generate(context, 'self-hosted');
-        else await selectedSubcommand.action(context);
+        await selectedSubcommand.action(context);
     } else {
         logger.error(`Unknown subcommand: ${selectedSubcommandName}`);
         telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
@@ -2989,8 +5733,7 @@ async function displayIntro(context, version) {
     });
     logger.message(coloredLines.join('\n'));
 }
-var constants = __webpack_require__("./src/constants.ts");
-function createErrorHandlers(context) {
+function error_handlers_createErrorHandlers(context) {
     const { logger, telemetry } = context;
     return {
         handleError: (error, message)=>{
@@ -3329,7 +6072,7 @@ async function createCliContext(rawArgs, cwd, commands) {
         cwd
     };
     const context = baseContext;
-    context.error = createErrorHandlers(context);
+    context.error = error_handlers_createErrorHandlers(context);
     const userInteraction = createUserInteraction(context);
     context.confirm = userInteraction.confirm;
     context.fs = createFileSystem(context);
@@ -3369,26 +6112,49 @@ async function createCliContext(rawArgs, cwd, commands) {
 }
 const src_commands = [
     {
-        name: 'generate',
-        label: 'Generate (Recommended)',
-        hint: 'Add c15t to your project',
-        description: 'Setup your c15t project',
+        name: 'setup',
+        label: 'Setup (Recommended)',
+        hint: 'Set up c15t in your project',
+        description: 'Set up c15t in your project.',
         action: (context)=>generate(context)
     },
-    {
-        name: 'self-host',
-        label: 'Self Host',
-        hint: 'Host c15t backend on your own infra',
-        description: 'Commands for self-hosting c15t (generate, migrate).',
-        action: (context)=>selfHost(context)
-    },
+    codemodsCommand,
     {
         name: 'skills',
         label: 'Skills',
-        hint: 'Add c15t agent skills for AI tools',
+        hint: 'Install c15t agent skills for AI tooling',
         description: 'Install c15t skills for AI-assisted development (Claude, Cursor, etc.)',
         action: (context)=>installSkills(context)
     },
+    {
+        name: 'docs',
+        label: 'Docs',
+        hint: 'Open c15t documentation',
+        description: 'Open the c15t documentation in your browser.',
+        action: async (context)=>{
+            const { logger } = context;
+            await (0, __rspack_external_open["default"])(`${constants.tl.DOCS}?ref=cli`);
+            logger.success('Documentation opened in your browser.');
+        }
+    },
+    {
+        name: 'changelog',
+        label: 'Changelog',
+        hint: 'Open the latest releases and changes',
+        description: 'Open the c15t changelog in your browser.',
+        action: async (context)=>{
+            const { logger } = context;
+            await (0, __rspack_external_open["default"])(constants.tl.CHANGELOG);
+            logger.success('Changelog opened in your browser.');
+        }
+    },
+    {
+        name: 'self-host',
+        label: 'Self-host',
+        hint: 'Self-hosted backend workflow tools',
+        description: 'Self-host workflow commands (migrations).',
+        action: (context)=>selfHost(context)
+    },
     {
         name: 'github',
         label: 'GitHub',
@@ -3400,17 +6166,6 @@ const src_commands = [
             await (0, __rspack_external_open["default"])(constants.tl.GITHUB);
             logger.success('Thank you for your support!');
         }
-    },
-    {
-        name: 'docs',
-        label: 'c15t docs',
-        hint: 'Open documentation',
-        description: 'Open the c15t documentation in your browser.',
-        action: async (context)=>{
-            const { logger } = context;
-            await (0, __rspack_external_open["default"])(`${constants.tl.DOCS}?ref=cli`);
-            logger.success('Documentation opened in your browser.');
-        }
     }
 ];
 async function main() {
@@ -3493,40 +6248,49 @@ flag or set ${external_picocolors_["default"].cyan('C15T_TELEMETRY_DISABLED=1')}
                 }));
             promptOptions.push({
                 value: 'exit',
-                label: 'exit',
+                label: 'Exit',
                 hint: 'Close the CLI'
             });
             const selectedCommandName = await prompts_.select({
                 message: (0, utils_logger.$e)('info', 'Which command would you like to run?'),
                 options: promptOptions
             });
-            if (prompts_.isCancel(selectedCommandName) || 'exit' === selectedCommandName) {
-                logger.debug('Interactive selection cancelled or exit chosen.');
+            if (prompts_.isCancel(selectedCommandName)) {
+                logger.debug('Interactive selection cancelled.');
                 telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
-                    action: prompts_.isCancel(selectedCommandName) ? 'cancelled' : 'exit'
+                    action: 'cancelled'
                 });
                 context.error.handleCancel('Operation cancelled.', {
                     command: 'interactive_menu',
                     stage: 'exit'
                 });
+                return;
+            }
+            if ('exit' === selectedCommandName) {
+                logger.debug('Interactive selection exited.');
+                telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
+                    action: 'exit'
+                });
+                logger.outro('Exited c15t CLI.');
+                telemetry.flushSync();
+                return;
+            }
+            const selectedCommand = src_commands.find((cmd)=>cmd.name === selectedCommandName);
+            if (selectedCommand) {
+                logger.debug(`User selected command: ${selectedCommand.name}`);
+                telemetry.trackCommand(selectedCommand.name, [], flags);
+                await selectedCommand.action(context);
+                telemetry.trackEvent(TelemetryEventName.COMMAND_SUCCEEDED, {
+                    command: selectedCommand.name,
+                    executionTime: Date.now() - performance.now()
+                });
+                telemetry.flushSync();
             } else {
-                const selectedCommand = src_commands.find((cmd)=>cmd.name === selectedCommandName);
-                if (selectedCommand) {
-                    logger.debug(`User selected command: ${selectedCommand.name}`);
-                    telemetry.trackCommand(selectedCommand.name, [], flags);
-                    await selectedCommand.action(context);
-                    telemetry.trackEvent(TelemetryEventName.COMMAND_SUCCEEDED, {
-                        command: selectedCommand.name,
-                        executionTime: Date.now() - performance.now()
-                    });
-                    telemetry.flushSync();
-                } else {
-                    telemetry.trackEvent(TelemetryEventName.COMMAND_UNKNOWN, {
-                        unknownCommand: String(selectedCommandName)
-                    });
-                    telemetry.flushSync();
-                    error.handleError(new Error(`Command '${selectedCommandName}' not found`), 'An internal error occurred');
-                }
+                telemetry.trackEvent(TelemetryEventName.COMMAND_UNKNOWN, {
+                    unknownCommand: String(selectedCommandName)
+                });
+                telemetry.flushSync();
+                error.handleError(new Error(`Command '${selectedCommandName}' not found`), 'An internal error occurred');
             }
         }
         logger.debug('Command execution completed');