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

package/dist/generate-files.mjs

@@ -0,0 +1,1771 @@
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import picocolors from "picocolors";
+import { Node, Project, SyntaxKind } from "ts-morph";
+import { formatSearchedCssPaths, ensureGlobalCssStylesheetImports, STORAGE_MODES, LAYOUT_PATTERNS, logger_formatLogMessage, PAGES_APP_PATTERNS as constants_PAGES_APP_PATTERNS, constants_REGEX } from "./145.mjs";
+function generateClientConfigContent(mode, backendURL, useEnvFile, enableDevTools = false) {
+    switch(mode){
+        case STORAGE_MODES.HOSTED:
+        case STORAGE_MODES.C15T:
+            return generateHostedConfig(backendURL, useEnvFile, enableDevTools);
+        case STORAGE_MODES.OFFLINE:
+            return generateOfflineConfig(enableDevTools);
+        case STORAGE_MODES.SELF_HOSTED:
+            return generateSelfHostedConfig(backendURL, useEnvFile, enableDevTools);
+        case STORAGE_MODES.CUSTOM:
+            return generateCustomConfig(backendURL, useEnvFile, enableDevTools);
+        default:
+            return generateOfflineConfig(enableDevTools);
+    }
+}
+function generateHostedConfig(backendURL, useEnvFile, enableDevTools = false) {
+    const url = useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL' : `'${backendURL || 'https://your-project.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: 'hosted',
+		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: 'hosted',
+		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")
+`;
+}
+async function updateAppStylesheetImports(options) {
+    return ensureGlobalCssStylesheetImports({
+        projectRoot: options.projectRoot,
+        packageName: options.packageName,
+        tailwindVersion: options.tailwindVersion,
+        entrypointPath: options.entrypointPath,
+        includeBase: true,
+        includeIab: options.includeIab ?? false,
+        dryRun: options.dryRun
+    });
+}
+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-project.c15t.dev\n`;
+}
+async function findMatchingFiles(projectRoot, patterns, logger) {
+    const matches = [];
+    for (const pattern of patterns){
+        const parts = pattern.split('/');
+        const hasWildcard = parts.some((p)=>'*' === p);
+        if (hasWildcard) {
+            const baseParts = [];
+            for (const part of parts){
+                if ('*' === part) break;
+                baseParts.push(part);
+            }
+            const baseDir = node_path.join(projectRoot, ...baseParts);
+            try {
+                const entries = await promises.readdir(baseDir, {
+                    withFileTypes: true
+                });
+                for (const entry of entries)if (entry.isDirectory()) {
+                    const remainingParts = parts.slice(baseParts.length + 1);
+                    const potentialPath = node_path.join(baseDir, entry.name, ...remainingParts);
+                    const relativePath = node_path.relative(projectRoot, potentialPath);
+                    const patternWithDir = pattern.replace('*', entry.name);
+                    if (relativePath === patternWithDir.replace(/\//g, node_path.sep)) try {
+                        await promises.access(potentialPath);
+                        logger?.debug(`Found layout: ${relativePath}`);
+                        matches.push(relativePath);
+                    } catch  {}
+                }
+            } catch  {}
+        } else {
+            const filePath = node_path.join(projectRoot, pattern);
+            try {
+                await promises.access(filePath);
+                logger?.debug(`Found layout: ${pattern}`);
+                matches.push(pattern);
+            } catch  {}
+        }
+    }
+    return matches;
+}
+function extractLocaleSegment(filepath) {
+    const match = filepath.match(constants_REGEX.DYNAMIC_SEGMENT);
+    return match ? match[0] : void 0;
+}
+function hasLocaleSegment(filepath) {
+    return constants_REGEX.DYNAMIC_SEGMENT.test(filepath);
+}
+function getAppDirectory(layoutPath) {
+    const parts = layoutPath.split(node_path.sep);
+    const appIndex = parts.indexOf('app');
+    if (-1 === appIndex) {
+        const pagesIndex = parts.indexOf('pages');
+        if (-1 !== pagesIndex) return parts.slice(0, pagesIndex + 1).join(node_path.sep);
+        return node_path.dirname(layoutPath);
+    }
+    if (hasLocaleSegment(layoutPath)) return parts.slice(0, appIndex + 2).join(node_path.sep);
+    return parts.slice(0, appIndex + 1).join(node_path.sep);
+}
+async function findLayoutFile(projectRoot, logger) {
+    logger?.debug(`Searching for layout file in ${projectRoot}`);
+    const appLayoutMatches = await findMatchingFiles(projectRoot, LAYOUT_PATTERNS, logger);
+    if (appLayoutMatches.length > 0) {
+        appLayoutMatches.sort((a, b)=>{
+            const aHasLocale = hasLocaleSegment(a);
+            const bHasLocale = hasLocaleSegment(b);
+            if (!aHasLocale && bHasLocale) return -1;
+            if (aHasLocale && !bHasLocale) return 1;
+            return a.length - b.length;
+        });
+        const layoutPath = appLayoutMatches[0];
+        const localeSegment = extractLocaleSegment(layoutPath);
+        logger?.debug(`Selected layout: ${layoutPath}`);
+        return {
+            path: layoutPath,
+            type: 'app',
+            hasLocaleSegment: !!localeSegment,
+            localeSegment,
+            appDirectory: getAppDirectory(layoutPath)
+        };
+    }
+    const pagesLayoutMatches = await findMatchingFiles(projectRoot, constants_PAGES_APP_PATTERNS, logger);
+    if (pagesLayoutMatches.length > 0) {
+        const layoutPath = pagesLayoutMatches[0];
+        logger?.debug(`Selected pages layout: ${layoutPath}`);
+        return {
+            path: layoutPath,
+            type: 'pages',
+            hasLocaleSegment: false,
+            appDirectory: getAppDirectory(layoutPath)
+        };
+    }
+    logger?.debug('No layout file found');
+    return null;
+}
+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 = '';
+    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 { DevTools } 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 ? "<DevTools 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://v2.c15t.com/docs/frameworks/${slug}/quickstart
+ */`;
+    }
+    if (initialDataProp) return `/**
+ * Consent management wrapper for Next.js Pages Router.
+ * @see https://v2.c15t.com/docs/frameworks/nextjs/quickstart
+ */`;
+    const slug = docsSlug || 'react';
+    return `/**
+ * Consent manager provider.
+ * @see https://v2.c15t.com/docs/frameworks/${slug}/quickstart
+ */`;
+}
+async function directory_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 = node_path.join(projectRoot, candidate);
+        const stat = await promises.stat(candidatePath);
+        if (stat.isDirectory()) return candidate;
+    } catch  {}
+    return isSrcDir ? 'src/components' : 'components';
+}
+function getFrameworkDirectory(filePath, dirName) {
+    const normalizedPath = node_path.normalize(filePath);
+    const srcSegment = node_path.join('src', dirName);
+    if (normalizedPath.includes(srcSegment)) return node_path.join('src', dirName);
+    return dirName;
+}
+function getSourceDirectory(filePath) {
+    const normalizedPath = node_path.normalize(filePath);
+    const segments = normalizedPath.split(node_path.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 { DevTools } 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://v2.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 ? "<DevTools disabled={process.env.NODE_ENV === 'production'} />" : ''}
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+}
+function generateExpandedConsentDialogTemplate(framework) {
+    return `'use client';
+
+import { useState } from 'react';
+import { ConsentDialog, ConsentWidget } from '${framework.consentDialogImport}';
+
+/**
+ * Consent dialog using compound components.
+ * @see https://v2.c15t.com/docs/frameworks/${framework.docsSlug}/components/consent-dialog
+ */
+export default function () {
+	const [openItem, setOpenItem] = useState('');
+
+	return (
+		<ConsentDialog.Root>
+			<ConsentDialog.Card>
+				<ConsentDialog.Header>
+					<ConsentDialog.HeaderTitle />
+					<ConsentDialog.HeaderDescription />
+				</ConsentDialog.Header>
+				<ConsentDialog.Content>
+					<ConsentWidget.Root>
+						<ConsentWidget.Accordion
+							type="single"
+							value={openItem}
+							onValueChange={(value) => {
+								setOpenItem(Array.isArray(value) ? (value[0] ?? '') : (value ?? ''));
+							}}
+						>
+							<ConsentWidget.AccordionItems />
+						</ConsentWidget.Accordion>
+						{/* Pass renderAction to customize mapping. Stock c15t buttons render by default. */}
+						<ConsentWidget.PolicyActions />
+					</ConsentWidget.Root>
+				</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://v2.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>
+				{/* Pass renderAction to customize mapping. Stock c15t buttons render by default. */}
+				<ConsentBanner.PolicyActions />
+			</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://v2.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://v2.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://v2.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 = node_path.dirname(fromFilePath);
+    let relativePath = node_path.relative(fromDir, toFilePath);
+    relativePath = relativePath.split(node_path.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, knownFilePath, frameworkDirName, createComponents, wrapJsx, afterImport } = config;
+    const project = new Project();
+    let layoutFile;
+    if (knownFilePath) try {
+        layoutFile = project.addSourceFileAtPath(knownFilePath);
+    } catch  {}
+    else 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-project.c15t.dev'}'`;
+}
+function generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs, inlineCustomHandlers, envVarPrefix = 'NEXT_PUBLIC') {
+    switch(mode){
+        case 'hosted':
+        case 'c15t':
+        case 'self-hosted':
+            {
+                const backendURLValue = getBackendURLValue(backendURL, useEnvFile, proxyNextjs, envVarPrefix);
+                return `mode: 'hosted',
+				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://v2.c15t.com/docs/frameworks/${framework.docsSlug}/quickstart
+ */
+export function ConsentManager({ children }: { children: ReactNode }) {
+	const ssrData = fetchInitialData({
+		backendURL: ${backendURLValue},
+	});
+
+	return (
+		<ConsentManagerProvider ssrData={ssrData}>
+			{children}
+		</ConsentManagerProvider>
+	);
+}
+`;
+    return `import type { ReactNode } from 'react';
+import ConsentManagerProvider from './provider';
+
+/**
+ * Consent management wrapper.
+ * @see https://v2.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://v2.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 directory_getComponentsDirectory(projectRoot, appDir);
+    const consentManagerDirPath = node_path.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 = node_path.join(consentManagerDirPath, 'index.tsx');
+    const providerPath = node_path.join(consentManagerDirPath, 'provider.tsx');
+    const consentBannerPath = node_path.join(consentManagerDirPath, 'consent-banner.tsx');
+    const consentDialogPath = node_path.join(consentManagerDirPath, 'consent-dialog.tsx');
+    const themePath = node_path.join(consentManagerDirPath, 'theme.ts');
+    await promises.mkdir(consentManagerDirPath, {
+        recursive: true
+    });
+    await Promise.all([
+        promises.writeFile(indexPath, serverComponentContent, 'utf-8'),
+        promises.writeFile(providerPath, providerContent, 'utf-8'),
+        promises.writeFile(consentBannerPath, consentBannerContent, 'utf-8'),
+        promises.writeFile(consentDialogPath, consentDialogContent, 'utf-8'),
+        promises.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 directory_getComponentsDirectory(projectRoot, appDir);
+    const consentManagerDirPath = node_path.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 = node_path.join(consentManagerDirPath, 'index.tsx');
+    const providerPath = node_path.join(consentManagerDirPath, 'provider.tsx');
+    await promises.mkdir(consentManagerDirPath, {
+        recursive: true
+    });
+    const writePromises = [
+        promises.writeFile(indexPath, consentManagerContent, 'utf-8'),
+        promises.writeFile(providerPath, consentManagerClientContent, 'utf-8')
+    ];
+    if (hasTheme) {
+        const themeContent = generateExpandedThemeTemplate(expandedTheme, NEXTJS_CONFIG);
+        const themePath = node_path.join(consentManagerDirPath, 'theme.ts');
+        writePromises.push(promises.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, layoutFilePath }) {
+    return runLayoutUpdatePipeline({
+        filePatterns: APP_LAYOUT_PATTERNS,
+        projectRoot,
+        knownFilePath: layoutFilePath,
+        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') ? node_path.join('src', 'components') : 'components';
+    const componentsDirPath = node_path.join(projectRoot, componentsDir);
+    await promises.mkdir(componentsDirPath, {
+        recursive: true
+    });
+    const consentManagerContent = generateConsentComponent({
+        importSource: '@c15t/nextjs',
+        optionsText,
+        selectedScripts,
+        initialDataProp: true,
+        enableDevTools,
+        includeOverrides: true
+    });
+    const consentManagerPath = node_path.join(componentsDirPath, 'consent-manager.tsx');
+    await promises.writeFile(consentManagerPath, consentManagerContent, 'utf-8');
+    return {
+        consentManager: consentManagerPath
+    };
+}
+function addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs) {
+    const existingComments = appFile.getLeadingCommentRanges();
+    let urlExample;
+    urlExample = proxyNextjs ? "'/api/c15t'" : useEnvFile ? 'process.env.NEXT_PUBLIC_C15T_URL!' : `'${backendURL || 'https://your-project.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, layoutFilePath }) {
+    const optionsText = generateOptionsText(mode, backendURL, useEnvFile, proxyNextjs);
+    return runLayoutUpdatePipeline({
+        filePatterns: PAGES_APP_PATTERNS,
+        projectRoot,
+        knownFilePath: layoutFilePath,
+        frameworkDirName: 'pages',
+        wrapJsx: wrapPagesJsxContent,
+        createComponents: async (_layoutFilePath, pagesDir)=>createConsentManagerComponent(projectRoot, pagesDir, optionsText, selectedScripts, enableDevTools),
+        afterImport: (appFile)=>{
+            updateAppComponentTyping(appFile);
+            addServerSideDataComment(appFile, backendURL, useEnvFile, proxyNextjs);
+        }
+    });
+}
+async function updateNextLayout(options) {
+    const layoutDetection = await findLayoutFile(options.projectRoot);
+    if (!layoutDetection) return {
+        updated: false,
+        filePath: null,
+        alreadyModified: false,
+        structureType: null
+    };
+    const structureType = layoutDetection.type;
+    const layoutFilePath = node_path.join(options.projectRoot, layoutDetection.path);
+    let result;
+    result = 'app' === structureType ? await updateAppLayout({
+        ...options,
+        layoutFilePath
+    }) : await updatePagesLayout({
+        ...options,
+        layoutFilePath
+    });
+    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 directory_getComponentsDirectory(projectRoot, sourceDir);
+    const consentManagerDirPath = node_path.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 = node_path.join(consentManagerDirPath, 'index.tsx');
+    const providerPath = node_path.join(consentManagerDirPath, 'provider.tsx');
+    await promises.mkdir(consentManagerDirPath, {
+        recursive: true
+    });
+    const writePromises = [
+        promises.writeFile(indexPath, indexContent, 'utf-8'),
+        promises.writeFile(providerPath, providerContent, 'utf-8')
+    ];
+    if (hasTheme) {
+        const themeContent = generateExpandedThemeTemplate(expandedTheme, REACT_CONFIG);
+        const themePath = node_path.join(consentManagerDirPath, 'theme.ts');
+        writePromises.push(promises.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-project.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 = node_path.relative(cwd, typedResult.componentFiles.consentManager);
+                const relativeLayout = node_path.relative(cwd, layoutResult.filePath || '');
+                if (typedResult.componentFiles.consentManagerDir) {
+                    const relativeConsentManagerDir = node_path.relative(cwd, typedResult.componentFiles.consentManagerDir);
+                    return {
+                        message: `Layout setup complete!\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(`${relativeConsentManagerDir}/`)} (expanded components)\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManager)}\n  ${picocolors.green('✓')} Updated: ${picocolors.cyan(relativeLayout)}`,
+                        type: 'info'
+                    };
+                }
+                if (typedResult.componentFiles.consentManagerClient) {
+                    const relativeConsentManagerClient = node_path.relative(cwd, typedResult.componentFiles.consentManagerClient);
+                    return {
+                        message: `Layout setup complete!\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManager)}\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManagerClient)}\n  ${picocolors.green('✓')} Updated: ${picocolors.cyan(relativeLayout)}`,
+                        type: 'info'
+                    };
+                }
+                return {
+                    message: `Layout setup complete!\n  ${picocolors.green('✓')} Created: ${picocolors.cyan(relativeConsentManager)}\n  ${picocolors.green('✓')} Updated: ${picocolors.cyan(relativeLayout)}`,
+                    type: 'info'
+                };
+            }
+            return {
+                message: `Layout file updated: ${layoutResult.filePath}`,
+                type: 'info'
+            };
+        }
+        return {
+            message: 'Layout file not updated.',
+            type: 'error'
+        };
+    };
+    const { message, type } = spinnerMessage();
+    spinner.stop(logger_formatLogMessage(type, message));
+    return {
+        layoutUpdated: layoutResult.updated,
+        layoutPath: layoutResult.filePath
+    };
+}
+async function handleNextConfig(options) {
+    const { projectRoot, backendURL, useEnvFile, spinner } = options;
+    spinner.start('Updating Next.js config...');
+    const configResult = await updateNextConfig({
+        projectRoot,
+        backendURL,
+        useEnvFile
+    });
+    const spinnerMessage = ()=>{
+        if (configResult.alreadyModified) return {
+            message: 'Next.js config already has c15t rewrite rule. Skipped config update.',
+            type: 'info'
+        };
+        if (configResult.updated && configResult.created) return {
+            message: `Next.js config created: ${configResult.filePath}`,
+            type: 'info'
+        };
+        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(logger_formatLogMessage(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 = node_path.join(projectRoot, '.env.local');
+    const envExamplePath = node_path.join(projectRoot, '.env.example');
+    spinner.start('Creating/updating environment files...');
+    const envContent = generateEnvFileContent(backendURL, pkg);
+    const envExampleContent = generateEnvExampleContent(pkg);
+    const envVarName = getEnvVarName(pkg);
+    try {
+        const [envExists, envExampleExists] = await Promise.all([
+            promises.access(envPath).then(()=>true).catch(()=>false),
+            promises.access(envExamplePath).then(()=>true).catch(()=>false)
+        ]);
+        if (envExists) {
+            const currentEnvContent = await promises.readFile(envPath, 'utf-8');
+            if (!currentEnvContent.includes(envVarName)) await promises.appendFile(envPath, envContent);
+        } else await promises.writeFile(envPath, envContent);
+        if (envExampleExists) {
+            const currentExampleContent = await promises.readFile(envExamplePath, 'utf-8');
+            if (!currentExampleContent.includes(envVarName)) await promises.appendFile(envExamplePath, envExampleContent);
+        } else await promises.writeFile(envExamplePath, envExampleContent);
+        spinner.stop(logger_formatLogMessage('info', `Environment files added/updated successfully: ${picocolors.cyan(node_path.relative(cwd, envPath))} and ${picocolors.cyan(node_path.relative(cwd, envExamplePath))}`));
+    } catch (error) {
+        spinner.stop(logger_formatLogMessage('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 && ('hosted' === mode || '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 = node_path.join(projectRoot, 'c15t.config.ts');
+        spinner.stop(logger_formatLogMessage('info', `Client configuration file generated: ${result.configContent}`));
+    }
+    if (useEnvFile && backendURL) await handleEnvFiles({
+        projectRoot,
+        backendURL,
+        pkg,
+        spinner,
+        cwd: context.cwd
+    });
+    if ('@c15t/react' === pkg || '@c15t/nextjs' === pkg) {
+        spinner.start('Configuring app stylesheet...');
+        const stylesheetResult = await updateAppStylesheetImports({
+            projectRoot,
+            packageName: pkg,
+            tailwindVersion: context.framework.tailwindVersion,
+            entrypointPath: result.layoutPath
+        });
+        if (stylesheetResult.updated) {
+            result.tailwindCssUpdated = true;
+            result.tailwindCssPath = stylesheetResult.filePath;
+            spinner.stop(logger_formatLogMessage('info', `App stylesheet updated: ${picocolors.cyan(node_path.relative(context.cwd, stylesheetResult.filePath || ''))}`));
+        } else if (stylesheetResult.filePath) spinner.stop(logger_formatLogMessage('debug', 'App stylesheet already had the correct c15t imports.'));
+        else spinner.stop(logger_formatLogMessage('warn', `Could not find a global CSS entrypoint. Checked: ${formatSearchedCssPaths(projectRoot, stylesheetResult.searchedPaths)}`));
+    }
+    return result;
+}
+export { generateFiles };