@c15t/cli 1.8.3 → 2.0.0-rc.1

package/dist/760.mjs

@@ -0,0 +1,1720 @@
+import { Node, Project, SyntaxKind } from "ts-morph";
+export const __rspack_esm_id = "760";
+export const __rspack_esm_ids = [
+    "760"
+];
+export const __webpack_modules__ = {
+    "./src/commands/generate/options/utils/generate-files.ts" (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            generateFiles: ()=>generateFiles
+        });
+        var promises_ = __webpack_require__("node:fs/promises");
+        var external_node_path_ = __webpack_require__("node:path");
+        var external_picocolors_ = __webpack_require__("picocolors");
+        var logger = __webpack_require__("./src/utils/logger.ts");
+        var constants = __webpack_require__("./src/constants.ts");
+        function generateClientConfigContent(mode, backendURL, useEnvFile, enableDevTools = false) {
+            switch(mode){
+                case constants.$V.C15T:
+                    return generateC15tConfig(backendURL, useEnvFile, enableDevTools);
+                case constants.$V.OFFLINE:
+                    return generateOfflineConfig(enableDevTools);
+                case constants.$V.SELF_HOSTED:
+                    return generateSelfHostedConfig(backendURL, useEnvFile, enableDevTools);
+                case constants.$V.CUSTOM:
+                    return generateCustomConfig(backendURL, useEnvFile, enableDevTools);
+                default:
+                    return generateOfflineConfig(enableDevTools);
+            }
+        }
+        function generateC15tConfig(backendURL, useEnvFile, enableDevTools = false) {
+            const url = useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL' : `'${backendURL || 'https://your-instance.c15t.dev'}'`;
+            const devToolsImport = enableDevTools ? "import { createDevTools } from '@c15t/dev-tools';\n" : '';
+            const devToolsCall = enableDevTools ? 'createDevTools();\n' : '';
+            return `import { getOrCreateConsentRuntime } from 'c15t';
+${devToolsImport}
+const runtime = getOrCreateConsentRuntime(
+	{
+		mode: 'c15t',
+		backendURL: ${url},
+		consentCategories: ['necessary', 'measurement', 'marketing'],
+	},
+);
+
+export const store = runtime.consentStore;
+${devToolsCall}
+/**
+ * Usage Examples
+ **/
+
+// View all consents
+// store.getState().consents;
+
+// Update a single consent type: (does not save automically, allowing you to batch updates together before saving)
+// store.getState().setSelectedConsent('measurement', true);
+
+// Update a single consent type and automically saves it
+// store.getState().setConsent('marketing', true);
+
+// When a user rejects all consents:
+// store.getState().saveConsents("necessary")
+`;
+        }
+        function generateOfflineConfig(enableDevTools = false) {
+            const devToolsImport = enableDevTools ? "import { createDevTools } from '@c15t/dev-tools';\n" : '';
+            const devToolsCall = enableDevTools ? 'createDevTools();\n' : '';
+            return `import { getOrCreateConsentRuntime } from 'c15t';
+${devToolsImport}
+const runtime = getOrCreateConsentRuntime(
+	{
+		mode: 'offline',
+		consentCategories: ['necessary', 'measurement', 'marketing'],
+	},
+);
+
+export const store = runtime.consentStore;
+${devToolsCall}
+/**
+ * Usage Examples
+ **/
+
+// View all consents
+// store.getState().consents;
+
+// Update a single consent type: (does not save automically, allowing you to batch updates together before saving)
+// store.getState().setSelectedConsent('measurement', true);
+
+// Update a single consent type and automically saves it
+// store.getState().setConsent('marketing', true);
+
+// When a user rejects all consents:
+// store.getState().saveConsents("necessary")
+`;
+        }
+        function generateSelfHostedConfig(backendURL, useEnvFile, enableDevTools = false) {
+            const url = useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL' : `'${backendURL || 'http://localhost:3001'}'`;
+            const devToolsImport = enableDevTools ? "import { createDevTools } from '@c15t/dev-tools';\n" : '';
+            const devToolsCall = enableDevTools ? 'createDevTools();\n' : '';
+            return `import { getOrCreateConsentRuntime } from 'c15t';
+${devToolsImport}
+const runtime = getOrCreateConsentRuntime(
+	{
+		mode: 'c15t',
+		backendURL: ${url},
+		consentCategories: ['necessary', 'measurement', 'marketing'],
+	},
+);
+
+export const store = runtime.consentStore;
+${devToolsCall}
+/**
+ * Usage Examples
+ **/
+
+// View all consents
+// store.getState().consents;
+
+// Update a single consent type: (does not save automically, allowing you to batch updates together before saving)
+// store.getState().setSelectedConsent('measurement', true);
+
+// Update a single consent type and automically saves it
+// store.getState().setConsent('marketing', true);
+
+// When a user rejects all consents:
+// store.getState().saveConsents("necessary")
+`;
+        }
+        function generateCustomConfig(backendURL, useEnvFile, enableDevTools = false) {
+            const url = useEnvFile ? 'process.env.NEXT_PUBLIC_CONSENT_API_URL' : `'${backendURL || '/api/consent'}'`;
+            const devToolsImport = enableDevTools ? "import { createDevTools } from '@c15t/dev-tools';\n" : '';
+            const devToolsCall = enableDevTools ? 'createDevTools();\n' : '';
+            return `import { getOrCreateConsentRuntime, type EndpointHandlers } from 'c15t';
+${devToolsImport}
+function createCustomHandlers(): EndpointHandlers {
+	return {
+		async getConsent() {
+			const response = await fetch(${url});
+			return response.json();
+		},
+		async setConsent(consent) {
+			const response = await fetch(${url}, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify(consent),
+			});
+			return response.json();
+		},
+	};
+}
+
+const runtime = getOrCreateConsentRuntime(
+	{
+		mode: 'custom',
+		endpointHandlers: createCustomHandlers(),
+		consentCategories: ['necessary', 'measurement', 'marketing'],
+	},
+);
+
+export const store = runtime.consentStore;
+${devToolsCall}
+/**
+ * Usage Examples
+ **/
+
+// View all consents
+// store.getState().consents;
+
+// Update a single consent type: (does not save automically, allowing you to batch updates together before saving)
+// store.getState().setSelectedConsent('measurement', true);
+
+// Update a single consent type and automically saves it
+// store.getState().setConsent('marketing', true);
+
+// When a user rejects all consents:
+// store.getState().saveConsents("necessary")
+`;
+        }
+        const CSS_PATTERNS = [
+            'app/globals.css',
+            'src/app/globals.css',
+            'app/global.css',
+            'src/app/global.css',
+            'styles/globals.css',
+            'src/styles/globals.css',
+            'styles/global.css',
+            'src/styles/global.css',
+            'src/index.css',
+            'src/App.css'
+        ];
+        async function updateTailwindCss(projectRoot, tailwindVersion) {
+            if (!tailwindVersion || !tailwindVersion.match(/^(?:\^|~)?3/)) return {
+                updated: false,
+                filePath: null
+            };
+            for (const pattern of CSS_PATTERNS){
+                const filePath = external_node_path_["default"].join(projectRoot, pattern);
+                try {
+                    await promises_["default"].access(filePath);
+                    const content = await promises_["default"].readFile(filePath, 'utf-8');
+                    if (content.includes('@layer base, components;')) return {
+                        updated: false,
+                        filePath
+                    };
+                    if (content.includes('@tailwind base') || content.includes('@tailwind components') || content.includes('@tailwind utilities')) {
+                        let newContent = content;
+                        if (newContent.includes('@tailwind base')) {
+                            newContent = newContent.replace('@tailwind base;', '@layer base {\n  @tailwind base;\n}');
+                            newContent = newContent.replace('@tailwind base\n', '@layer base {\n  @tailwind base;\n}\n');
+                        }
+                        if (!newContent.includes('@layer base, components;')) newContent = `@layer base, components;\n\n${newContent}`;
+                        await promises_["default"].writeFile(filePath, newContent, 'utf-8');
+                        return {
+                            updated: true,
+                            filePath
+                        };
+                    }
+                } catch  {}
+            }
+            return {
+                updated: false,
+                filePath: null
+            };
+        }
+        function getEnvVarName(pkg) {
+            return '@c15t/nextjs' === pkg ? 'NEXT_PUBLIC_C15T_URL' : 'PUBLIC_C15T_URL';
+        }
+        function generateEnvFileContent(backendURL, pkg) {
+            const envVarName = getEnvVarName(pkg);
+            return `\n${envVarName}=${backendURL}\n`;
+        }
+        function generateEnvExampleContent(pkg) {
+            const envVarName = getEnvVarName(pkg);
+            return `\n# c15t Configuration\n${envVarName}=https://your-instance.c15t.dev\n`;
+        }
+        function toCamelCase(scriptName) {
+            return scriptName.replace(/-([a-z])/g, (_, letter)=>letter.toUpperCase());
+        }
+        function generateScriptsImport(selectedScripts) {
+            if (!selectedScripts.length) return '';
+            return selectedScripts.map((script)=>`import { ${toCamelCase(script)} } from '@c15t/scripts/${script}';`).join('\n');
+        }
+        function generateScriptsConfig(selectedScripts) {
+            if (!selectedScripts.length) return '';
+            const scriptConfigs = selectedScripts.map((script)=>{
+                const funcName = toCamelCase(script);
+                const idPlaceholder = getIdPlaceholder(script);
+                return `${funcName}({ id: '${idPlaceholder}' })`;
+            });
+            return `scripts: [
+					${scriptConfigs.join(',\n\t\t\t\t\t')},
+				],`;
+        }
+        function getIdPlaceholder(scriptName) {
+            switch(scriptName){
+                case 'google-tag-manager':
+                    return 'GTM-XXXXXX';
+                case 'google-tag':
+                    return 'G-XXXXXXXXXX';
+                case 'meta-pixel':
+                    return 'XXXXXXXXXXXXXXXXXX';
+                case 'posthog':
+                    return 'phc_XXXXXXXXXX';
+                case 'linkedin-insights':
+                    return 'XXXXXXX';
+                case 'tiktok-pixel':
+                    return 'XXXXXXXXXXXXXXXXX';
+                case 'x-pixel':
+                    return 'XXXXX';
+                case 'microsoft-uet':
+                    return 'XXXXXXXXXX';
+                case 'databuddy':
+                    return 'YOUR_ID_HERE';
+                default:
+                    return 'YOUR_ID_HERE';
+            }
+        }
+        function generateScriptsCommentPlaceholder() {
+            return `// Add your scripts here:
+				// import { googleTagManager } from '@c15t/scripts/google-tag-manager';
+				// scripts: [
+				//   googleTagManager({ id: 'GTM-XXXXXX' }),
+				// ],`;
+        }
+        function generateConsentComponent({ importSource, optionsText, selectedScripts = [], initialDataProp = false, useClientDirective = false, defaultExport = false, ssrDataOption = false, includeOverrides = false, enableDevTools = false, useFrameworkProps, includeTheme = false, docsSlug }) {
+            const scriptsImport = generateScriptsImport(selectedScripts);
+            const scriptsConfig = selectedScripts.length ? generateScriptsConfig(selectedScripts) : generateScriptsCommentPlaceholder();
+            const ssrDataLine = ssrDataOption ? '\n\t\t\t\tssrData,' : '';
+            const themeLine = includeTheme ? '\n\t\t\t\ttheme,' : '';
+            const overridesLine = includeOverrides ? `\n\t\t\t\t// Shows banner during development. Remove for production.\n\t\t\t\toverrides: { country: 'DE' },` : '';
+            const fullOptionsText = `{
+			${optionsText}${ssrDataLine}${themeLine}
+			${scriptsConfig}${overridesLine}
+		}`;
+            const useConsentManagerProps = useFrameworkProps && ssrDataOption;
+            const needsDataType = (initialDataProp || ssrDataOption) && !useConsentManagerProps;
+            const namedImports = needsDataType ? `ConsentDialog,
+	ConsentManagerProvider,
+	ConsentBanner,
+	type InitialDataPromise` : `ConsentDialog,
+	ConsentManagerProvider,
+	ConsentBanner,`;
+            const frameworkPropsImport = useConsentManagerProps ? `import type { ConsentManagerProps } from '${useFrameworkProps}';\n` : '';
+            let propsDestructure;
+            propsDestructure = useConsentManagerProps ? "{ children, ssrData }: ConsentManagerProps" : ssrDataOption ? `{
+	children,
+	ssrData,
+}: {
+	children: ReactNode;
+	ssrData?: InitialDataPromise;
+}` : initialDataProp ? `{
+	children,
+	initialData,
+}: {
+	children: ReactNode;
+	initialData?: InitialDataPromise;
+}` : '{ children }: { children: ReactNode }';
+            const providerProps = initialDataProp ? `\n\t\t\tinitialData={initialData}\n\t\t\toptions={${fullOptionsText}}` : ` options={${fullOptionsText}}`;
+            const directive = useClientDirective ? "'use client';\n\n" : '';
+            const devToolsImport = enableDevTools ? "import { C15TDevTools } from '@c15t/dev-tools/react';\n" : '';
+            const themeImport = includeTheme ? "import { theme } from './theme';\n" : '';
+            const componentName = defaultExport ? 'ConsentManagerClient' : 'ConsentManager';
+            const exportPrefix = defaultExport ? 'export default function' : 'export function';
+            const docComment = buildDocComment({
+                defaultExport,
+                initialDataProp,
+                ssrDataOption,
+                docsSlug
+            });
+            const preDocComment = initialDataProp ? `// For client-only apps (non-SSR), you can use:
+// import { ConsentManagerProvider } from '@c15t/nextjs/client';
+
+` : '';
+            return `${directive}import type { ReactNode } from 'react';
+import {
+	${namedImports}
+} from '${importSource}';
+${frameworkPropsImport}${devToolsImport}${themeImport}${scriptsImport ? `${scriptsImport}\n` : ''}${preDocComment}${docComment}
+${exportPrefix} ${componentName}(${propsDestructure}) {
+	return (
+		<ConsentManagerProvider${providerProps}>
+			<ConsentBanner />
+			<ConsentDialog />
+			${enableDevTools ? "<C15TDevTools disabled={process.env.NODE_ENV === 'production'} />" : ''}
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+        }
+        function buildDocComment({ defaultExport, initialDataProp, ssrDataOption, docsSlug }) {
+            if (defaultExport) {
+                const slug = docsSlug || 'nextjs';
+                return `/**
+ * Client-side consent manager provider.
+ * @see https://c15t.com/docs/frameworks/${slug}/quickstart
+ */`;
+            }
+            if (initialDataProp) return `/**
+ * Consent management wrapper for Next.js Pages Router.
+ * @see https://c15t.com/docs/frameworks/nextjs/quickstart
+ */`;
+            const slug = docsSlug || 'react';
+            return `/**
+ * Consent manager provider.
+ * @see https://c15t.com/docs/frameworks/${slug}/quickstart
+ */`;
+        }
+        async function getComponentsDirectory(projectRoot, sourceDir) {
+            const isSrcDir = 'src' === sourceDir || sourceDir.startsWith('src');
+            const candidates = isSrcDir ? [
+                'src/components',
+                'components'
+            ] : [
+                'components',
+                'src/components'
+            ];
+            for (const candidate of candidates)try {
+                const candidatePath = external_node_path_["default"].join(projectRoot, candidate);
+                const stat = await promises_["default"].stat(candidatePath);
+                if (stat.isDirectory()) return candidate;
+            } catch  {}
+            return isSrcDir ? 'src/components' : 'components';
+        }
+        function getFrameworkDirectory(filePath, dirName) {
+            const normalizedPath = external_node_path_["default"].normalize(filePath);
+            const srcSegment = external_node_path_["default"].join('src', dirName);
+            if (normalizedPath.includes(srcSegment)) return external_node_path_["default"].join('src', dirName);
+            return dirName;
+        }
+        function getSourceDirectory(filePath) {
+            const normalizedPath = external_node_path_["default"].normalize(filePath);
+            const segments = normalizedPath.split(external_node_path_["default"].sep);
+            if (segments.includes('src')) return 'src';
+            return '';
+        }
+        function generateExpandedProviderTemplate({ enableSSR, enableDevTools, optionsText, framework }) {
+            const useConsentManagerProps = enableSSR && framework.hasSSRProps;
+            let propsInterface;
+            let propsDestructure;
+            let typeImports;
+            if (useConsentManagerProps) {
+                propsInterface = '';
+                propsDestructure = '{ children, ssrData }: ConsentManagerProps';
+                typeImports = `import type { ConsentManagerProps } from '${framework.importSource}';`;
+            } else if (enableSSR) {
+                propsInterface = `\ninterface Props {
+	children: ReactNode;
+	ssrData?: InitialDataPromise;
+}\n`;
+                propsDestructure = '{ children, ssrData }: Props';
+                typeImports = `import type { InitialDataPromise } from '${framework.importSource}';`;
+            } else {
+                propsInterface = `\ninterface Props {
+	children: ReactNode;
+}\n`;
+                propsDestructure = '{ children }: Props';
+                typeImports = '';
+            }
+            const ssrDataOption = enableSSR ? '\n\t\t\t\tssrData,' : '';
+            const devToolsImport = enableDevTools ? "import { C15TDevTools } from '@c15t/dev-tools/react';\n" : '';
+            const reactNodeImport = useConsentManagerProps ? '' : "import type { ReactNode } from 'react';\n";
+            return `'use client';
+
+${reactNodeImport}import { ConsentManagerProvider } from '${framework.importSource}';
+${typeImports}
+${devToolsImport}import ConsentBanner from './consent-banner';
+import ConsentDialog from './consent-dialog';
+import { theme } from './theme';
+${propsInterface}
+/**
+ * Client-side consent manager provider with compound components.
+ * @see https://c15t.com/docs/frameworks/${framework.docsSlug}/quickstart
+ */
+export default function ConsentManagerClient(${propsDestructure}) {
+	return (
+		<ConsentManagerProvider
+			options={{
+				${optionsText}${ssrDataOption}
+				theme,
+				// Add your scripts here:
+				// scripts: [
+				//   googleTagManager({ id: 'GTM-XXXXXX' }),
+				// ],${!enableSSR ? "\n\t\t\t\t// Shows banner during development. Remove for production.\n\t\t\t\toverrides: { country: 'DE' }," : ''}
+			}}
+		>
+			<ConsentBanner />
+			<ConsentDialog />
+			${enableDevTools ? "<C15TDevTools disabled={process.env.NODE_ENV === 'production'} />" : ''}
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+        }
+        function generateExpandedConsentDialogTemplate(framework) {
+            return `'use client';
+
+import { ConsentWidget } from '${framework.importSource}';
+import { ConsentDialog } from '${framework.consentDialogImport}';
+
+/**
+ * Consent dialog using compound components.
+ * @see https://c15t.com/docs/frameworks/${framework.docsSlug}/components/consent-dialog
+ */
+export default function () {
+	return (
+		<ConsentDialog.Root>
+			<ConsentDialog.Card>
+				<ConsentDialog.Header>
+					<ConsentDialog.HeaderTitle />
+					<ConsentDialog.HeaderDescription />
+				</ConsentDialog.Header>
+				<ConsentDialog.Content>
+					<ConsentWidget />
+				</ConsentDialog.Content>
+				<ConsentDialog.Footer />
+			</ConsentDialog.Card>
+		</ConsentDialog.Root>
+	);
+}
+`;
+        }
+        function generateExpandedConsentBannerTemplate(framework) {
+            return `'use client';
+
+import { ConsentBanner } from '${framework.consentBannerImport}';
+
+/**
+ * Consent banner using compound components.
+ * @see https://c15t.com/docs/frameworks/${framework.docsSlug}/components/consent-banner
+ */
+export default function () {
+	return (
+		<ConsentBanner.Root>
+			<ConsentBanner.Card>
+				<ConsentBanner.Header>
+					<ConsentBanner.Title />
+					<ConsentBanner.Description
+						legalLinks={['privacyPolicy', 'termsOfService']}
+					/>
+				</ConsentBanner.Header>
+				<ConsentBanner.Footer>
+					<ConsentBanner.FooterSubGroup>
+						<ConsentBanner.RejectButton />
+						<ConsentBanner.AcceptButton />
+					</ConsentBanner.FooterSubGroup>
+					<ConsentBanner.CustomizeButton />
+				</ConsentBanner.Footer>
+			</ConsentBanner.Card>
+		</ConsentBanner.Root>
+	);
+}
+`;
+        }
+        function generateExpandedThemeTemplate(theme, framework) {
+            switch(theme){
+                case 'tailwind':
+                    return generateTailwindTheme(framework);
+                case 'minimal':
+                    return generateMinimalTheme(framework);
+                case 'dark':
+                    return generateDarkTheme(framework);
+                default:
+                    return generateTailwindTheme(framework);
+            }
+        }
+        function generateTailwindTheme(framework) {
+            return `import type { Theme } from '${framework.importSource}';
+
+/**
+ * Tailwind Theme
+ *
+ * Uses standard Tailwind colors (Slate/Blue) with backdrop blur effects.
+ * This theme works well with Tailwind CSS projects.
+ *
+ * Customize the colors, typography, and slots below to match your design.
+ *
+ * @see https://c15t.com/docs/customization/theming
+ */
+export const theme: Theme = {
+	colors: {
+		primary: '#3b82f6', // blue-500
+		primaryHover: '#2563eb', // blue-600
+		surface: '#ffffff',
+		surfaceHover: '#f8fafc', // slate-50
+		border: '#e2e8f0', // slate-200
+		borderHover: '#cbd5e1', // slate-300
+		text: '#0f172a', // slate-900
+		textMuted: '#64748b', // slate-500
+		textOnPrimary: '#ffffff',
+		switchTrack: '#e2e8f0',
+		switchTrackActive: '#3b82f6',
+		switchThumb: '#ffffff',
+	},
+	typography: {
+		fontFamily: 'ui-sans-serif, system-ui, -apple-system, sans-serif',
+	},
+	radius: {
+		sm: '0.125rem',
+		md: '0.375rem',
+		lg: '0.5rem',
+		full: '9999px',
+	},
+	slots: {
+		consentBannerCard:
+			'border border-slate-200 bg-white/95 backdrop-blur-sm shadow-md',
+		consentDialogCard:
+			'border border-slate-200 bg-white/95 backdrop-blur-md shadow-xl',
+		buttonPrimary:
+			'bg-blue-600 text-white hover:bg-blue-700 shadow-sm transition-colors',
+		buttonSecondary:
+			'bg-white text-slate-600 border border-slate-200 hover:bg-slate-50 transition-colors',
+		consentBannerTitle: 'text-slate-900 font-semibold',
+		consentBannerDescription: 'text-slate-500',
+	},
+};
+`;
+        }
+        function generateMinimalTheme(framework) {
+            return `import type { Theme } from '${framework.importSource}';
+
+/**
+ * Minimal Theme
+ *
+ * A clean, light theme with subtle grays and refined typography.
+ * Uses standard CSS (no Tailwind dependency).
+ *
+ * Customize the colors, typography, and slots below to match your design.
+ *
+ * @see https://c15t.com/docs/customization/theming
+ */
+export const theme: Theme = {
+	colors: {
+		primary: '#18181b',
+		primaryHover: '#27272a',
+		surface: '#ffffff',
+		surfaceHover: '#fafafa',
+		border: '#e4e4e7',
+		borderHover: '#d4d4d8',
+		text: '#18181b',
+		textMuted: '#71717a',
+		textOnPrimary: '#ffffff',
+		switchTrack: '#d4d4d8',
+		switchTrackActive: '#18181b',
+		switchThumb: '#ffffff',
+	},
+	dark: {
+		primary: '#fafafa',
+		primaryHover: '#e4e4e7',
+		surface: '#0a0a0a',
+		surfaceHover: '#171717',
+		border: '#27272a',
+		borderHover: '#3f3f46',
+		text: '#fafafa',
+		textMuted: '#a1a1aa',
+		textOnPrimary: '#09090b',
+	},
+	typography: {
+		fontFamily: 'var(--font-inter), system-ui, sans-serif',
+		fontSize: {
+			sm: '0.8125rem',
+			base: '0.875rem',
+			lg: '1rem',
+		},
+		fontWeight: {
+			normal: 400,
+			medium: 500,
+			semibold: 500,
+		},
+		lineHeight: {
+			tight: '1.3',
+			normal: '1.5',
+			relaxed: '1.7',
+		},
+	},
+	radius: {
+		sm: '0.25rem',
+		md: '0.375rem',
+		lg: '0.5rem',
+		full: '9999px',
+	},
+	shadows: {
+		sm: '0 1px 2px rgba(0, 0, 0, 0.04)',
+		md: '0 2px 8px rgba(0, 0, 0, 0.06)',
+		lg: '0 4px 16px rgba(0, 0, 0, 0.08)',
+	},
+	slots: {
+		consentBannerCard: {
+			style: {
+				border: '1px solid var(--c15t-border)',
+				boxShadow: 'var(--c15t-shadow-sm)',
+			},
+		},
+		consentDialogCard: {
+			style: {
+				border: '1px solid var(--c15t-border)',
+				boxShadow: 'var(--c15t-shadow-lg)',
+			},
+		},
+		buttonPrimary: {
+			style: {
+				borderRadius: 'var(--c15t-radius-sm)',
+				boxShadow: 'none',
+				fontWeight: 500,
+			},
+		},
+		buttonSecondary: {
+			style: {
+				borderRadius: 'var(--c15t-radius-sm)',
+				backgroundColor: 'transparent',
+				border: '1px solid var(--c15t-border)',
+				color: 'var(--c15t-text-muted)',
+				boxShadow: 'none',
+				fontWeight: 500,
+			},
+		},
+	},
+};
+`;
+        }
+        function generateDarkTheme(framework) {
+            return `import type { Theme } from '${framework.importSource}';
+
+/**
+ * Dark Mode Theme
+ *
+ * High contrast black and white theme.
+ * Stays dark regardless of system preference.
+ * Uses standard CSS (no Tailwind dependency).
+ *
+ * Customize the colors, typography, and slots below to match your design.
+ *
+ * @see https://c15t.com/docs/customization/theming
+ */
+export const theme: Theme = {
+	colors: {
+		// Define dark colors as the default to enforce dark mode
+		primary: '#ffffff',
+		primaryHover: '#ededed',
+		surface: '#000000',
+		surfaceHover: '#111111',
+		border: '#333333',
+		borderHover: '#444444',
+		text: '#ffffff',
+		textMuted: '#888888',
+		textOnPrimary: '#000000',
+		switchTrack: '#333333',
+		switchTrackActive: '#ffffff',
+		switchThumb: '#000000',
+	},
+	// No 'dark' overrides needed as the base IS dark
+	typography: {
+		fontFamily: 'var(--font-inter), system-ui, sans-serif',
+		fontSize: {
+			sm: '0.8125rem',
+			base: '0.875rem',
+			lg: '1rem',
+		},
+		fontWeight: {
+			normal: 400,
+			medium: 500,
+			semibold: 600,
+		},
+	},
+	radius: {
+		sm: '0.25rem',
+		md: '0.375rem',
+		lg: '0.5rem',
+		full: '9999px',
+	},
+	shadows: {
+		sm: '0 1px 2px rgba(255, 255, 255, 0.1)',
+		md: '0 4px 8px rgba(0, 0, 0, 0.5)',
+		lg: '0 8px 16px rgba(0, 0, 0, 0.5)',
+	},
+	slots: {
+		consentBannerCard: {
+			style: {
+				backgroundColor: '#000000',
+				border: '1px solid #333333',
+				boxShadow: 'none',
+			},
+		},
+		consentDialogCard: {
+			style: {
+				backgroundColor: '#000000',
+				border: '1px solid #333333',
+				boxShadow: '0 0 0 1px #333333, 0 8px 40px rgba(0,0,0,0.5)',
+			},
+		},
+		buttonPrimary: {
+			style: {
+				backgroundColor: '#ffffff',
+				color: '#000000',
+				border: '1px solid #ffffff',
+				boxShadow: 'none',
+				fontWeight: 500,
+			},
+		},
+		buttonSecondary: {
+			style: {
+				backgroundColor: '#000000',
+				border: '1px solid #333333',
+				color: '#888888',
+				boxShadow: 'none',
+				fontWeight: 500,
+			},
+		},
+	},
+};
+`;
+        }
+        const NEXTJS_CONFIG = {
+            importSource: '@c15t/nextjs',
+            consentBannerImport: '@c15t/nextjs',
+            consentDialogImport: '@c15t/nextjs',
+            frameworkName: 'Next.js App Router',
+            ssrMechanism: 'Next.js headers() API',
+            docsSlug: 'nextjs',
+            envVarPrefix: 'NEXT_PUBLIC',
+            hasSSRProps: true
+        };
+        const REACT_CONFIG = {
+            importSource: '@c15t/react',
+            consentBannerImport: '@c15t/react',
+            consentDialogImport: '@c15t/react',
+            frameworkName: 'React',
+            ssrMechanism: '',
+            docsSlug: 'react',
+            envVarPrefix: '',
+            hasSSRProps: false
+        };
+        function computeRelativeModuleSpecifier(fromFilePath, toFilePath) {
+            const fromDir = external_node_path_["default"].dirname(fromFilePath);
+            let relativePath = external_node_path_["default"].relative(fromDir, toFilePath);
+            relativePath = relativePath.split(external_node_path_["default"].sep).join('/');
+            relativePath = relativePath.replace(/\.(tsx?|jsx?)$/, '');
+            relativePath = relativePath.replace(/\/index$/, '');
+            if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
+            return relativePath;
+        }
+        function hasConsentManagerImport(sourceFile, moduleSpecifier) {
+            const existingImports = sourceFile.getImportDeclarations();
+            return existingImports.some((importDecl)=>{
+                const spec = importDecl.getModuleSpecifierValue();
+                return './consent-manager' === spec || './consent-manager.tsx' === spec || spec.endsWith('/consent-manager') || spec.endsWith('/consent-manager/index') || void 0 !== moduleSpecifier && spec === moduleSpecifier;
+            });
+        }
+        function addConsentManagerImport(sourceFile, consentManagerFilePath) {
+            const sourceFilePath = sourceFile.getFilePath();
+            const moduleSpecifier = computeRelativeModuleSpecifier(sourceFilePath, consentManagerFilePath);
+            if (!hasConsentManagerImport(sourceFile, moduleSpecifier)) sourceFile.addImportDeclaration({
+                namedImports: [
+                    'ConsentManager'
+                ],
+                moduleSpecifier
+            });
+        }
+        async function runLayoutUpdatePipeline(config) {
+            const { filePatterns, projectRoot, frameworkDirName, createComponents, wrapJsx, afterImport } = config;
+            const project = new Project();
+            let layoutFile;
+            for (const pattern of filePatterns){
+                const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
+                if (files.length > 0) {
+                    layoutFile = files[0];
+                    break;
+                }
+            }
+            if (!layoutFile) return {
+                updated: false,
+                filePath: null,
+                alreadyModified: false
+            };
+            const layoutFilePath = layoutFile.getFilePath();
+            const frameworkDir = getFrameworkDirectory(layoutFilePath, frameworkDirName);
+            if (hasConsentManagerImport(layoutFile)) return {
+                updated: false,
+                filePath: layoutFilePath,
+                alreadyModified: true
+            };
+            const componentFiles = await createComponents(layoutFilePath, frameworkDir);
+            addConsentManagerImport(layoutFile, componentFiles.consentManager);
+            if (afterImport) afterImport(layoutFile);
+            const returnStatement = layoutFile.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
+            if (!returnStatement) return {
+                updated: false,
+                filePath: layoutFilePath,
+                alreadyModified: false
+            };
+            const expression = returnStatement.getExpression();
+            if (!expression) return {
+                updated: false,
+                filePath: layoutFilePath,
+                alreadyModified: false
+            };
+            const originalJsx = expression.getText();
+            const newJsx = wrapJsx(originalJsx);
+            returnStatement.replaceWithText(`return ${newJsx}`);
+            await layoutFile.save();
+            return {
+                updated: true,
+                filePath: layoutFilePath,
+                alreadyModified: false,
+                componentFiles
+            };
+        }
+        function getBackendURLValue(backendURL, useEnvFile, proxyNextjs, envVarPrefix = 'NEXT_PUBLIC') {
+            if (proxyNextjs) return '"/api/c15t"';
+            if (useEnvFile) return `process.env.${envVarPrefix}_C15T_URL!`;
+            return `'${backendURL || 'https://your-instance.c15t.dev'}'`;
+        }
+        function generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs, inlineCustomHandlers, envVarPrefix = 'NEXT_PUBLIC') {
+            switch(mode){
+                case 'c15t':
+                case 'self-hosted':
+                    {
+                        const backendURLValue = getBackendURLValue(backendURL, useEnvFile, proxyNextjs, envVarPrefix);
+                        return `mode: 'c15t',
+				backendURL: ${backendURLValue},`;
+                    }
+                case 'custom':
+                    if (inlineCustomHandlers) {
+                        const url = useEnvFile ? `process.env.${envVarPrefix}_CONSENT_API_URL` : `'${backendURL || '/api/consent'}'`;
+                        return `mode: 'custom',
+			endpointHandlers: {
+				async getConsent() {
+					const res = await fetch(${url});
+					return res.json();
+				},
+				async setConsent(consent) {
+					const res = await fetch(${url}, {
+						method: 'POST',
+						headers: { 'Content-Type': 'application/json' },
+						body: JSON.stringify(consent),
+					});
+					return res.json();
+				},
+			},`;
+                    }
+                    return `mode: 'custom',
+				endpointHandlers: createCustomHandlers(),`;
+                default:
+                    return "mode: 'offline',";
+            }
+        }
+        function generateServerComponent({ enableSSR, backendURLValue, framework }) {
+            if (enableSSR) return `import { fetchInitialData } from '${framework.importSource}';
+import type { ReactNode } from 'react';
+import ConsentManagerProvider from './provider';
+
+/**
+ * Server-side consent management wrapper with SSR data prefetching.
+ * @see https://c15t.com/docs/frameworks/${framework.docsSlug}/quickstart
+ */
+export function ConsentManager({ children }: { children: ReactNode }) {
+	const ssrData = fetchInitialData({
+		backendURL: ${backendURLValue},
+		// Shows banner during development. Remove for production.
+		overrides: { country: 'DE' },
+	});
+
+	return (
+		<ConsentManagerProvider ssrData={ssrData}>
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+            return `import type { ReactNode } from 'react';
+import ConsentManagerProvider from './provider';
+
+/**
+ * Consent management wrapper.
+ * @see https://c15t.com/docs/frameworks/${framework.docsSlug}/quickstart
+ */
+export function ConsentManager({ children }: { children: ReactNode }) {
+	return (
+		<ConsentManagerProvider>
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+        }
+        function generateSimpleWrapperComponent(_frameworkName, docsSlug) {
+            return `import type { ReactNode } from 'react';
+import ConsentManagerProvider from './provider';
+
+/**
+ * Consent management wrapper.
+ * @see https://c15t.com/docs/frameworks/${docsSlug}/quickstart
+ */
+export function ConsentManager({ children }: { children: ReactNode }) {
+	return <ConsentManagerProvider>{children}</ConsentManagerProvider>;
+}
+`;
+        }
+        const HTML_TAG_REGEX = /<html[^>]*>([\s\S]*)<\/html>/;
+        const BODY_TAG_REGEX = /<body[^>]*>([\s\S]*)<\/body>/;
+        const BODY_OPENING_TAG_REGEX = /<body[^>]*>/;
+        const HTML_CONTENT_REGEX = /([\s\S]*<\/html>)/;
+        function wrapAppJsxContent(originalJsx) {
+            const hasHtmlTag = originalJsx.includes('<html') || originalJsx.includes('</html>');
+            const hasBodyTag = originalJsx.includes('<body') || originalJsx.includes('</body>');
+            const consentWrapper = (content)=>`
+		<ConsentManager>
+			${content}
+		</ConsentManager>
+	`;
+            if (hasHtmlTag) {
+                const htmlMatch = originalJsx.match(HTML_TAG_REGEX);
+                const htmlContent = htmlMatch?.[1] || '';
+                if (!htmlContent) return consentWrapper(originalJsx);
+                const bodyMatch = htmlContent.match(BODY_TAG_REGEX);
+                if (!bodyMatch) return originalJsx.replace(HTML_CONTENT_REGEX, `<html>${consentWrapper('$1')}</html>`);
+                const bodyContent = bodyMatch[1] || '';
+                const bodyOpeningTag = originalJsx.match(BODY_OPENING_TAG_REGEX)?.[0] || '<body>';
+                return originalJsx.replace(BODY_TAG_REGEX, `${bodyOpeningTag}${consentWrapper(bodyContent)}</body>`);
+            }
+            if (hasBodyTag) {
+                const bodyMatch = originalJsx.match(BODY_TAG_REGEX);
+                const bodyContent = bodyMatch?.[1] || '';
+                if (!bodyContent) return consentWrapper(originalJsx);
+                const bodyOpeningTag = originalJsx.match(BODY_OPENING_TAG_REGEX)?.[0] || '<body>';
+                return originalJsx.replace(BODY_TAG_REGEX, `${bodyOpeningTag}${consentWrapper(bodyContent)}</body>`);
+            }
+            return consentWrapper(originalJsx);
+        }
+        async function createExpandedConsentManagerComponents(projectRoot, appDir, options) {
+            const { mode, backendURL, useEnvFile, proxyNextjs, enableSSR, enableDevTools, expandedTheme } = options;
+            const componentsDir = await getComponentsDirectory(projectRoot, appDir);
+            const consentManagerDirPath = external_node_path_["default"].join(projectRoot, componentsDir, 'consent-manager');
+            const backendURLValue = getBackendURLValue(backendURL, useEnvFile, proxyNextjs, NEXTJS_CONFIG.envVarPrefix);
+            const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs, void 0, NEXTJS_CONFIG.envVarPrefix);
+            const serverComponentContent = generateServerComponent({
+                enableSSR,
+                backendURLValue,
+                framework: NEXTJS_CONFIG
+            });
+            const providerContent = generateExpandedProviderTemplate({
+                enableSSR,
+                enableDevTools: Boolean(enableDevTools),
+                optionsText,
+                framework: NEXTJS_CONFIG
+            });
+            const consentBannerContent = generateExpandedConsentBannerTemplate(NEXTJS_CONFIG);
+            const consentDialogContent = generateExpandedConsentDialogTemplate(NEXTJS_CONFIG);
+            const themeContent = generateExpandedThemeTemplate(expandedTheme, NEXTJS_CONFIG);
+            const indexPath = external_node_path_["default"].join(consentManagerDirPath, 'index.tsx');
+            const providerPath = external_node_path_["default"].join(consentManagerDirPath, 'provider.tsx');
+            const consentBannerPath = external_node_path_["default"].join(consentManagerDirPath, 'consent-banner.tsx');
+            const consentDialogPath = external_node_path_["default"].join(consentManagerDirPath, 'consent-dialog.tsx');
+            const themePath = external_node_path_["default"].join(consentManagerDirPath, 'theme.ts');
+            await promises_["default"].mkdir(consentManagerDirPath, {
+                recursive: true
+            });
+            await Promise.all([
+                promises_["default"].writeFile(indexPath, serverComponentContent, 'utf-8'),
+                promises_["default"].writeFile(providerPath, providerContent, 'utf-8'),
+                promises_["default"].writeFile(consentBannerPath, consentBannerContent, 'utf-8'),
+                promises_["default"].writeFile(consentDialogPath, consentDialogContent, 'utf-8'),
+                promises_["default"].writeFile(themePath, themeContent, 'utf-8')
+            ]);
+            return {
+                consentManager: indexPath,
+                consentManagerDir: consentManagerDirPath
+            };
+        }
+        async function createPrebuiltConsentManagerComponents(projectRoot, appDir, options) {
+            const { mode, backendURL, useEnvFile, proxyNextjs, enableSSR, enableDevTools, expandedTheme, selectedScripts } = options;
+            const hasTheme = expandedTheme && 'none' !== expandedTheme;
+            const componentsDir = await getComponentsDirectory(projectRoot, appDir);
+            const consentManagerDirPath = external_node_path_["default"].join(projectRoot, componentsDir, 'consent-manager');
+            const backendURLValue = getBackendURLValue(backendURL, useEnvFile, proxyNextjs, NEXTJS_CONFIG.envVarPrefix);
+            const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs, void 0, NEXTJS_CONFIG.envVarPrefix);
+            const consentManagerContent = generateServerComponent({
+                enableSSR,
+                backendURLValue,
+                framework: NEXTJS_CONFIG
+            });
+            const consentManagerClientContent = generateConsentComponent({
+                importSource: NEXTJS_CONFIG.importSource,
+                optionsText,
+                selectedScripts,
+                useClientDirective: true,
+                defaultExport: true,
+                ssrDataOption: enableSSR,
+                includeOverrides: !enableSSR,
+                enableDevTools: Boolean(enableDevTools),
+                useFrameworkProps: enableSSR ? NEXTJS_CONFIG.importSource : void 0,
+                includeTheme: Boolean(hasTheme),
+                docsSlug: NEXTJS_CONFIG.docsSlug
+            });
+            const indexPath = external_node_path_["default"].join(consentManagerDirPath, 'index.tsx');
+            const providerPath = external_node_path_["default"].join(consentManagerDirPath, 'provider.tsx');
+            await promises_["default"].mkdir(consentManagerDirPath, {
+                recursive: true
+            });
+            const writePromises = [
+                promises_["default"].writeFile(indexPath, consentManagerContent, 'utf-8'),
+                promises_["default"].writeFile(providerPath, consentManagerClientContent, 'utf-8')
+            ];
+            if (hasTheme) {
+                const themeContent = generateExpandedThemeTemplate(expandedTheme, NEXTJS_CONFIG);
+                const themePath = external_node_path_["default"].join(consentManagerDirPath, 'theme.ts');
+                writePromises.push(promises_["default"].writeFile(themePath, themeContent, 'utf-8'));
+            }
+            await Promise.all(writePromises);
+            return {
+                consentManager: indexPath,
+                consentManagerClient: providerPath
+            };
+        }
+        const APP_LAYOUT_PATTERNS = [
+            'app/layout.tsx',
+            'src/app/layout.tsx',
+            'app/layout.ts',
+            'src/app/layout.ts'
+        ];
+        async function updateAppLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs, enableSSR = false, enableDevTools = false, uiStyle = 'prebuilt', expandedTheme = 'tailwind', selectedScripts }) {
+            return runLayoutUpdatePipeline({
+                filePatterns: APP_LAYOUT_PATTERNS,
+                projectRoot,
+                frameworkDirName: 'app',
+                wrapJsx: wrapAppJsxContent,
+                createComponents: async (_layoutFilePath, appDir)=>{
+                    if ('expanded' === uiStyle) return createExpandedConsentManagerComponents(projectRoot, appDir, {
+                        mode,
+                        backendURL,
+                        useEnvFile,
+                        proxyNextjs,
+                        enableSSR,
+                        enableDevTools,
+                        expandedTheme
+                    });
+                    return createPrebuiltConsentManagerComponents(projectRoot, appDir, {
+                        mode,
+                        backendURL,
+                        useEnvFile,
+                        proxyNextjs,
+                        enableSSR,
+                        enableDevTools,
+                        expandedTheme,
+                        selectedScripts
+                    });
+                }
+            });
+        }
+        function wrapPagesJsxContent(originalJsx) {
+            const trimmedJsx = originalJsx.trim();
+            const hasParentheses = trimmedJsx.startsWith('(') && trimmedJsx.endsWith(')');
+            const cleanJsx = hasParentheses ? trimmedJsx.slice(1, -1).trim() : originalJsx;
+            const wrappedContent = `
+		<ConsentManager initialData={pageProps.initialC15TData}>
+			${cleanJsx}
+		</ConsentManager>
+	`;
+            return `(${wrappedContent})`;
+        }
+        async function createConsentManagerComponent(projectRoot, pagesDir, optionsText, selectedScripts, enableDevTools) {
+            let componentsDir;
+            componentsDir = pagesDir.includes('src') ? external_node_path_["default"].join('src', 'components') : 'components';
+            const componentsDirPath = external_node_path_["default"].join(projectRoot, componentsDir);
+            await promises_["default"].mkdir(componentsDirPath, {
+                recursive: true
+            });
+            const consentManagerContent = generateConsentComponent({
+                importSource: '@c15t/nextjs',
+                optionsText,
+                selectedScripts,
+                initialDataProp: true,
+                enableDevTools,
+                includeOverrides: true
+            });
+            const consentManagerPath = external_node_path_["default"].join(componentsDirPath, 'consent-manager.tsx');
+            await promises_["default"].writeFile(consentManagerPath, consentManagerContent, 'utf-8');
+            return {
+                consentManager: consentManagerPath
+            };
+        }
+        function addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs) {
+            const existingComments = appFile.getLeadingCommentRanges();
+            let urlExample;
+            urlExample = proxyNextjs ? "'/api/c15t'" : useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL!' : `'${backendURL || 'https://your-instance.c15t.dev'}'`;
+            const serverSideComment = `/**
+ * Note: To get the initial server-side data on other pages, add this to each page:
+ *
+ * import { withInitialC15TData } from '@c15t/nextjs';
+ *
+ * export const getServerSideProps = withInitialC15TData(${urlExample});
+ *
+ * This will automatically pass initialC15TData to pageProps.initialC15TData
+ */`;
+            const hasServerSideComment = existingComments.some((comment)=>comment.getText().includes('withInitialC15TData'));
+            if (!hasServerSideComment) appFile.insertText(0, `${serverSideComment}\n\n`);
+        }
+        function updateAppComponentTyping(appFile) {
+            const exportAssignment = appFile.getExportAssignment(()=>true);
+            if (!exportAssignment) return;
+            const declaration = exportAssignment.getExpression();
+            if (!declaration) return;
+            const text = declaration.getText();
+            if (text.includes('pageProps') && !text.includes('AppProps')) {
+                const hasAppPropsImport = appFile.getImportDeclarations().some((importDecl)=>'next/app' === importDecl.getModuleSpecifierValue() && importDecl.getNamedImports().some((namedImport)=>'AppProps' === namedImport.getName()));
+                if (!hasAppPropsImport) appFile.addImportDeclaration({
+                    namedImports: [
+                        'AppProps'
+                    ],
+                    moduleSpecifier: 'next/app'
+                });
+            }
+        }
+        const PAGES_APP_PATTERNS = [
+            'pages/_app.tsx',
+            'pages/_app.ts',
+            'src/pages/_app.tsx',
+            'src/pages/_app.ts'
+        ];
+        async function updatePagesLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs, enableDevTools = false, selectedScripts }) {
+            const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs);
+            return runLayoutUpdatePipeline({
+                filePatterns: PAGES_APP_PATTERNS,
+                projectRoot,
+                frameworkDirName: 'pages',
+                wrapJsx: wrapPagesJsxContent,
+                createComponents: async (_layoutFilePath, pagesDir)=>createConsentManagerComponent(projectRoot, pagesDir, optionsText, selectedScripts, enableDevTools),
+                afterImport: (appFile)=>{
+                    updateAppComponentTyping(appFile);
+                    addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs);
+                }
+            });
+        }
+        function detectNextJsStructure(projectRoot) {
+            const project = new Project();
+            const appLayoutPatterns = [
+                'app/layout.tsx',
+                'src/app/layout.tsx',
+                'app/layout.ts',
+                'src/app/layout.ts'
+            ];
+            for (const pattern of appLayoutPatterns){
+                const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
+                if (files.length > 0) return 'app';
+            }
+            const pagesAppPatterns = [
+                'pages/_app.tsx',
+                'pages/_app.ts',
+                'src/pages/_app.tsx',
+                'src/pages/_app.ts'
+            ];
+            for (const pattern of pagesAppPatterns){
+                const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
+                if (files.length > 0) return 'pages';
+            }
+            return null;
+        }
+        async function updateNextLayout(options) {
+            const structureType = detectNextJsStructure(options.projectRoot);
+            if (!structureType) return {
+                updated: false,
+                filePath: null,
+                alreadyModified: false,
+                structureType: null
+            };
+            let result;
+            result = 'app' === structureType ? await updateAppLayout(options) : await updatePagesLayout(options);
+            return {
+                ...result,
+                structureType
+            };
+        }
+        function updateGenericReactJsx(layoutFile) {
+            const functionDeclarations = layoutFile.getFunctions();
+            const variableDeclarations = layoutFile.getVariableDeclarations();
+            for (const func of functionDeclarations){
+                const returnStatement = func.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
+                if (returnStatement) return wrapReturnStatementWithConsentManager(returnStatement);
+            }
+            for (const varDecl of variableDeclarations){
+                const initializer = varDecl.getInitializer();
+                if (initializer) {
+                    const returnStatement = initializer.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0];
+                    if (returnStatement) return wrapReturnStatementWithConsentManager(returnStatement);
+                }
+            }
+            return false;
+        }
+        function wrapReturnStatementWithConsentManager(returnStatement) {
+            const expression = returnStatement.getExpression();
+            if (!expression) return false;
+            let originalJsx = expression.getText();
+            if (originalJsx.startsWith('(') && originalJsx.endsWith(')')) originalJsx = originalJsx.slice(1, -1).trim();
+            const newJsx = `(
+		<ConsentManager>
+			${originalJsx}
+		</ConsentManager>
+	)`;
+            returnStatement.replaceWithText(`return ${newJsx}`);
+            return true;
+        }
+        async function layout_createConsentManagerComponent(projectRoot, sourceDir, mode, backendURL, useEnvFile, selectedScripts, enableDevTools, expandedTheme) {
+            const hasTheme = expandedTheme && 'none' !== expandedTheme;
+            const componentsDir = await getComponentsDirectory(projectRoot, sourceDir);
+            const consentManagerDirPath = external_node_path_["default"].join(projectRoot, componentsDir, 'consent-manager');
+            const optionsText = generateOptionsText(mode, backendURL, useEnvFile, void 0, true);
+            const providerContent = generateConsentComponent({
+                importSource: '@c15t/react',
+                optionsText,
+                selectedScripts,
+                enableDevTools,
+                useClientDirective: true,
+                defaultExport: true,
+                includeTheme: Boolean(hasTheme),
+                includeOverrides: true,
+                docsSlug: 'react'
+            });
+            const indexContent = generateSimpleWrapperComponent('React', 'react');
+            const indexPath = external_node_path_["default"].join(consentManagerDirPath, 'index.tsx');
+            const providerPath = external_node_path_["default"].join(consentManagerDirPath, 'provider.tsx');
+            await promises_["default"].mkdir(consentManagerDirPath, {
+                recursive: true
+            });
+            const writePromises = [
+                promises_["default"].writeFile(indexPath, indexContent, 'utf-8'),
+                promises_["default"].writeFile(providerPath, providerContent, 'utf-8')
+            ];
+            if (hasTheme) {
+                const themeContent = generateExpandedThemeTemplate(expandedTheme, REACT_CONFIG);
+                const themePath = external_node_path_["default"].join(consentManagerDirPath, 'theme.ts');
+                writePromises.push(promises_["default"].writeFile(themePath, themeContent, 'utf-8'));
+            }
+            await Promise.all(writePromises);
+            return {
+                consentManager: indexPath,
+                consentManagerDir: consentManagerDirPath
+            };
+        }
+        async function updateGenericReactLayout({ projectRoot, mode, backendURL, useEnvFile, proxyNextjs, selectedScripts, enableDevTools, expandedTheme }) {
+            const layoutPatterns = [
+                'app.tsx',
+                'App.tsx',
+                'app.jsx',
+                'App.jsx',
+                'src/app.tsx',
+                'src/App.tsx',
+                'src/app.jsx',
+                'src/App.jsx',
+                'src/app/app.tsx',
+                'src/app/App.tsx',
+                'src/app/app.jsx',
+                'src/app/App.jsx'
+            ];
+            const project = new Project();
+            let layoutFile;
+            for (const pattern of layoutPatterns)try {
+                const files = project.addSourceFilesAtPaths(`${projectRoot}/${pattern}`);
+                if (files.length > 0) {
+                    layoutFile = files[0];
+                    break;
+                }
+            } catch  {}
+            if (!layoutFile) return {
+                updated: false,
+                filePath: null,
+                alreadyModified: false
+            };
+            const layoutFilePath = layoutFile.getFilePath();
+            const sourceDir = getSourceDirectory(layoutFilePath);
+            if (hasConsentManagerImport(layoutFile)) return {
+                updated: false,
+                filePath: layoutFilePath,
+                alreadyModified: true
+            };
+            try {
+                const componentFiles = await layout_createConsentManagerComponent(projectRoot, sourceDir, mode, backendURL, useEnvFile, selectedScripts, enableDevTools, expandedTheme);
+                addConsentManagerImport(layoutFile, componentFiles.consentManager);
+                const updated = updateGenericReactJsx(layoutFile);
+                if (updated) {
+                    await layoutFile.save();
+                    return {
+                        updated: true,
+                        filePath: layoutFilePath,
+                        alreadyModified: false,
+                        componentFiles
+                    };
+                }
+                return {
+                    updated: false,
+                    filePath: layoutFilePath,
+                    alreadyModified: false
+                };
+            } catch (error) {
+                throw new Error(`Failed to update generic React layout: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        async function updateReactLayout(options) {
+            if ('@c15t/nextjs' === options.pkg) {
+                const nextResult = await updateNextLayout(options);
+                if (nextResult.structureType) return {
+                    updated: nextResult.updated,
+                    filePath: nextResult.filePath,
+                    alreadyModified: nextResult.alreadyModified,
+                    componentFiles: nextResult.componentFiles
+                };
+            }
+            return updateGenericReactLayout(options);
+        }
+        async function updateNextConfig({ projectRoot, backendURL, useEnvFile }) {
+            const project = new Project();
+            const configFile = findNextConfigFile(project, projectRoot);
+            if (!configFile) {
+                const newConfigPath = `${projectRoot}/next.config.ts`;
+                const newConfig = createNewNextConfig(backendURL, useEnvFile);
+                const newConfigFile = project.createSourceFile(newConfigPath, newConfig);
+                await newConfigFile.save();
+                return {
+                    updated: true,
+                    filePath: newConfigPath,
+                    alreadyModified: false,
+                    created: true
+                };
+            }
+            if (hasC15tRewriteRule(configFile)) return {
+                updated: false,
+                filePath: configFile.getFilePath(),
+                alreadyModified: true,
+                created: false
+            };
+            const updated = await updateExistingConfig(configFile, backendURL, useEnvFile);
+            if (updated) await configFile.save();
+            return {
+                updated,
+                filePath: configFile.getFilePath(),
+                alreadyModified: false,
+                created: false
+            };
+        }
+        function findNextConfigFile(project, projectRoot) {
+            const configPatterns = [
+                'next.config.ts',
+                'next.config.js',
+                'next.config.mjs'
+            ];
+            for (const pattern of configPatterns){
+                const configPath = `${projectRoot}/${pattern}`;
+                try {
+                    const files = project.addSourceFilesAtPaths(configPath);
+                    if (files.length > 0) return files[0];
+                } catch  {}
+            }
+        }
+        function hasC15tRewriteRule(configFile) {
+            const text = configFile.getFullText();
+            return text.includes('/api/c15t/') || text.includes("'/api/c15t/:path*'");
+        }
+        function generateRewriteDestination(backendURL, useEnvFile) {
+            if (useEnvFile) return {
+                destination: '${process.env.NEXT_PUBLIC_C15T_URL}/:path*',
+                isTemplateLiteral: true
+            };
+            return {
+                destination: `${backendURL || 'https://your-instance.c15t.dev'}/:path*`,
+                isTemplateLiteral: false
+            };
+        }
+        function createNewNextConfig(backendURL, useEnvFile) {
+            const { destination, isTemplateLiteral } = generateRewriteDestination(backendURL, useEnvFile);
+            const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
+            return `import type { NextConfig } from 'next';
+
+const config: NextConfig = {
+	async rewrites() {
+		return [
+			{
+				source: '/api/c15t/:path*',
+				destination: ${destinationValue},
+			},
+		];
+	},
+};
+
+export default config;
+`;
+        }
+        function createRewriteRule(destination, isTemplateLiteral) {
+            const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
+            return `{
+		source: '/api/c15t/:path*',
+		destination: ${destinationValue},
+	}`;
+        }
+        function updateExistingConfig(configFile, backendURL, useEnvFile) {
+            const { destination, isTemplateLiteral } = generateRewriteDestination(backendURL, useEnvFile);
+            const configObject = findConfigObject(configFile);
+            if (!configObject) return false;
+            const rewritesProperty = configObject.getProperty('rewrites');
+            if (rewritesProperty && Node.isMethodDeclaration(rewritesProperty)) return updateExistingRewrites(rewritesProperty, destination, isTemplateLiteral);
+            if (rewritesProperty && Node.isPropertyAssignment(rewritesProperty)) return updatePropertyAssignmentRewrites(rewritesProperty, destination, isTemplateLiteral);
+            return addNewRewritesMethod(configObject, destination, isTemplateLiteral);
+        }
+        function findConfigObject(configFile) {
+            return findConfigFromExportDefault(configFile) || findConfigFromVariableDeclarations(configFile);
+        }
+        function findConfigFromExportDefault(configFile) {
+            const exportDefault = configFile.getDefaultExportSymbol();
+            if (!exportDefault) return;
+            const declarations = exportDefault.getDeclarations();
+            for (const declaration of declarations)if (Node.isExportAssignment(declaration)) {
+                const result = findConfigFromExpression(declaration.getExpression(), configFile);
+                if (result) return result;
+            }
+        }
+        function findConfigFromExpression(expression, configFile) {
+            if (Node.isCallExpression(expression)) return findConfigFromCallExpression(expression, configFile);
+            if (Node.isObjectLiteralExpression(expression)) return expression;
+            if (Node.isIdentifier(expression)) return findConfigFromIdentifier(expression.getText(), configFile);
+        }
+        function findConfigFromCallExpression(expression, configFile) {
+            const args = expression.getArguments();
+            if (0 === args.length) return;
+            const firstArg = args[0];
+            if (Node.isCallExpression(firstArg)) {
+                const innerArgs = firstArg.getArguments();
+                if (innerArgs.length > 0 && Node.isIdentifier(innerArgs[0])) return findConfigFromIdentifier(innerArgs[0].getText(), configFile);
+            }
+        }
+        function findConfigFromIdentifier(identifierText, configFile) {
+            const configVar = configFile.getVariableDeclaration(identifierText);
+            const initializer = configVar?.getInitializer();
+            return initializer && Node.isObjectLiteralExpression(initializer) ? initializer : void 0;
+        }
+        function findConfigFromVariableDeclarations(configFile) {
+            const variableDeclarations = configFile.getVariableDeclarations();
+            for (const varDecl of variableDeclarations){
+                const typeNode = varDecl.getTypeNode();
+                if (typeNode?.getText().includes('NextConfig')) {
+                    const initializer = varDecl.getInitializer();
+                    if (Node.isObjectLiteralExpression(initializer)) return initializer;
+                }
+            }
+        }
+        function updateExistingRewrites(rewritesMethod, destination, isTemplateLiteral) {
+            const body = rewritesMethod.getBody();
+            if (!Node.isBlock(body)) return false;
+            const returnStatement = body.getStatements().find((stmt)=>Node.isReturnStatement(stmt));
+            if (!returnStatement || !Node.isReturnStatement(returnStatement)) return false;
+            const expression = returnStatement.getExpression();
+            if (!expression || !Node.isArrayLiteralExpression(expression)) return false;
+            const newRewrite = createRewriteRule(destination, isTemplateLiteral);
+            const elements = expression.getElements();
+            if (elements.length > 0) expression.insertElement(0, newRewrite);
+            else expression.addElement(newRewrite);
+            return true;
+        }
+        function updatePropertyAssignmentRewrites(rewritesProperty, destination, isTemplateLiteral) {
+            const initializer = rewritesProperty.getInitializer();
+            if (Node.isArrayLiteralExpression(initializer)) {
+                const newRewrite = createRewriteRule(destination, isTemplateLiteral);
+                initializer.insertElement(0, newRewrite);
+                return true;
+            }
+            return false;
+        }
+        function addNewRewritesMethod(configObject, destination, isTemplateLiteral) {
+            const destinationValue = isTemplateLiteral ? `\`${destination}\`` : `'${destination}'`;
+            const rewritesMethod = `async rewrites() {
+		return [
+			{
+				source: '/api/c15t/:path*',
+				destination: ${destinationValue},
+			},
+		];
+	}`;
+            configObject.addProperty(rewritesMethod);
+            return true;
+        }
+        async function handleReactLayout(options) {
+            const { projectRoot, mode, backendURL, useEnvFile, proxyNextjs, enableSSR, enableDevTools, uiStyle, expandedTheme, selectedScripts, pkg, spinner, cwd } = options;
+            spinner.start('Updating layout file...');
+            const layoutResult = await updateReactLayout({
+                projectRoot,
+                mode,
+                backendURL,
+                useEnvFile,
+                proxyNextjs,
+                enableSSR,
+                enableDevTools,
+                uiStyle,
+                expandedTheme,
+                selectedScripts,
+                pkg
+            });
+            const spinnerMessage = ()=>{
+                if (layoutResult.alreadyModified) return {
+                    message: 'ConsentManager is already imported. Skipped layout file update.',
+                    type: 'info'
+                };
+                if (layoutResult.updated) {
+                    const typedResult = layoutResult;
+                    if (typedResult.componentFiles) {
+                        const relativeConsentManager = external_node_path_["default"].relative(cwd, typedResult.componentFiles.consentManager);
+                        const relativeLayout = external_node_path_["default"].relative(cwd, layoutResult.filePath || '');
+                        if (typedResult.componentFiles.consentManagerDir) {
+                            const relativeConsentManagerDir = external_node_path_["default"].relative(cwd, typedResult.componentFiles.consentManagerDir);
+                            return {
+                                message: `Layout setup complete!\n  ${external_picocolors_["default"].green('✓')} Created: ${external_picocolors_["default"].cyan(relativeConsentManagerDir + '/')} (expanded components)\n  ${external_picocolors_["default"].green('✓')} Created: ${external_picocolors_["default"].cyan(relativeConsentManager)}\n  ${external_picocolors_["default"].green('✓')} Updated: ${external_picocolors_["default"].cyan(relativeLayout)}`,
+                                type: 'info'
+                            };
+                        }
+                        if (typedResult.componentFiles.consentManagerClient) {
+                            const relativeConsentManagerClient = external_node_path_["default"].relative(cwd, typedResult.componentFiles.consentManagerClient);
+                            return {
+                                message: `Layout setup complete!\n  ${external_picocolors_["default"].green('✓')} Created: ${external_picocolors_["default"].cyan(relativeConsentManager)}\n  ${external_picocolors_["default"].green('✓')} Created: ${external_picocolors_["default"].cyan(relativeConsentManagerClient)}\n  ${external_picocolors_["default"].green('✓')} Updated: ${external_picocolors_["default"].cyan(relativeLayout)}`,
+                                type: 'info'
+                            };
+                        }
+                        return {
+                            message: `Layout setup complete!\n  ${external_picocolors_["default"].green('✓')} Created: ${external_picocolors_["default"].cyan(relativeConsentManager)}\n  ${external_picocolors_["default"].green('✓')} Updated: ${external_picocolors_["default"].cyan(relativeLayout)}`,
+                            type: 'info'
+                        };
+                    }
+                    return {
+                        message: `Layout file updated: ${layoutResult.filePath}`,
+                        type: 'info'
+                    };
+                }
+                return {
+                    message: 'Layout file not updated.',
+                    type: 'error'
+                };
+            };
+            const { message, type } = spinnerMessage();
+            spinner.stop((0, logger.$e)(type, message));
+            return {
+                layoutUpdated: layoutResult.updated,
+                layoutPath: layoutResult.filePath
+            };
+        }
+        async function handleNextConfig(options) {
+            const { projectRoot, backendURL, useEnvFile, spinner } = options;
+            spinner.start('Updating Next.js config...');
+            const configResult = await updateNextConfig({
+                projectRoot,
+                backendURL,
+                useEnvFile
+            });
+            const spinnerMessage = ()=>{
+                if (configResult.alreadyModified) return {
+                    message: 'Next.js config already has c15t rewrite rule. Skipped config update.',
+                    type: 'info'
+                };
+                if (configResult.updated && configResult.created) return {
+                    message: `Next.js config created: ${configResult.filePath}`,
+                    type: 'info'
+                };
+                if (configResult.updated) return {
+                    message: `Next.js config updated: ${configResult.filePath}`,
+                    type: 'info'
+                };
+                return {
+                    message: 'Next.js config not updated.',
+                    type: 'error'
+                };
+            };
+            const { message, type } = spinnerMessage();
+            spinner.stop((0, logger.$e)(type, message));
+            return {
+                nextConfigUpdated: configResult.updated,
+                nextConfigPath: configResult.filePath,
+                nextConfigCreated: configResult.created
+            };
+        }
+        async function handleEnvFiles(options) {
+            const { projectRoot, backendURL, pkg, spinner, cwd } = options;
+            const envPath = external_node_path_["default"].join(projectRoot, '.env.local');
+            const envExamplePath = external_node_path_["default"].join(projectRoot, '.env.example');
+            spinner.start('Creating/updating environment files...');
+            const envContent = generateEnvFileContent(backendURL, pkg);
+            const envExampleContent = generateEnvExampleContent(pkg);
+            const envVarName = getEnvVarName(pkg);
+            try {
+                const [envExists, envExampleExists] = await Promise.all([
+                    promises_["default"].access(envPath).then(()=>true).catch(()=>false),
+                    promises_["default"].access(envExamplePath).then(()=>true).catch(()=>false)
+                ]);
+                if (envExists) {
+                    const currentEnvContent = await promises_["default"].readFile(envPath, 'utf-8');
+                    if (!currentEnvContent.includes(envVarName)) await promises_["default"].appendFile(envPath, envContent);
+                } else await promises_["default"].writeFile(envPath, envContent);
+                if (envExampleExists) {
+                    const currentExampleContent = await promises_["default"].readFile(envExamplePath, 'utf-8');
+                    if (!currentExampleContent.includes(envVarName)) await promises_["default"].appendFile(envExamplePath, envExampleContent);
+                } else await promises_["default"].writeFile(envExamplePath, envExampleContent);
+                spinner.stop((0, logger.$e)('info', `Environment files added/updated successfully: ${external_picocolors_["default"].cyan(external_node_path_["default"].relative(cwd, envPath))} and ${external_picocolors_["default"].cyan(external_node_path_["default"].relative(cwd, envExamplePath))}`));
+            } catch (error) {
+                spinner.stop((0, logger.$e)('error', `Error processing environment files: ${error instanceof Error ? error.message : String(error)}`));
+                throw error;
+            }
+        }
+        async function generateFiles({ context, mode, spinner, useEnvFile, proxyNextjs, backendURL, enableSSR, enableDevTools, uiStyle, expandedTheme, selectedScripts }) {
+            const result = {
+                layoutUpdated: false
+            };
+            const { projectRoot, framework: { pkg } } = context;
+            if ('@c15t/nextjs' === pkg || '@c15t/react' === pkg) {
+                const layoutResult = await handleReactLayout({
+                    projectRoot,
+                    mode,
+                    backendURL,
+                    useEnvFile,
+                    proxyNextjs,
+                    enableSSR,
+                    enableDevTools,
+                    uiStyle,
+                    expandedTheme,
+                    selectedScripts,
+                    pkg,
+                    spinner,
+                    cwd: context.cwd
+                });
+                result.layoutUpdated = layoutResult.layoutUpdated;
+                result.layoutPath = layoutResult.layoutPath;
+            }
+            if ('@c15t/nextjs' === pkg && proxyNextjs && ('c15t' === mode || 'self-hosted' === mode)) {
+                const configResult = await handleNextConfig({
+                    projectRoot,
+                    backendURL,
+                    useEnvFile,
+                    spinner
+                });
+                result.nextConfigUpdated = configResult.nextConfigUpdated;
+                result.nextConfigPath = configResult.nextConfigPath;
+                result.nextConfigCreated = configResult.nextConfigCreated;
+            }
+            if ('c15t' === pkg) {
+                spinner.start('Generating client configuration file...');
+                result.configContent = generateClientConfigContent(mode, backendURL, useEnvFile, enableDevTools);
+                result.configPath = external_node_path_["default"].join(projectRoot, 'c15t.config.ts');
+                spinner.stop((0, logger.$e)('info', `Client configuration file generated: ${result.configContent}`));
+            }
+            if (useEnvFile && backendURL) await handleEnvFiles({
+                projectRoot,
+                backendURL,
+                pkg,
+                spinner,
+                cwd: context.cwd
+            });
+            if (context.framework.tailwindVersion) {
+                spinner.start('Checking Tailwind CSS compatibility...');
+                const tailwindResult = await updateTailwindCss(projectRoot, context.framework.tailwindVersion);
+                if (tailwindResult.updated) {
+                    result.tailwindCssUpdated = true;
+                    result.tailwindCssPath = tailwindResult.filePath;
+                    spinner.stop((0, logger.$e)('info', `Tailwind CSS updated for v3 compatibility: ${external_picocolors_["default"].cyan(external_node_path_["default"].relative(context.cwd, tailwindResult.filePath || ''))}`));
+                } else spinner.stop((0, logger.$e)('debug', 'Tailwind CSS update not needed.'));
+            }
+            return result;
+        }
+    }
+};