meno-core 1.0.21 → 1.0.23

package/build-static.test.ts

@@ -0,0 +1,424 @@
+/**
+ * Tests for build-static.ts - Static Site Generation Build Script
+ *
+ * Tests pure/exported functions directly. Integration tests for buildStaticPages()
+ * require extensive mocking of the project context and are out of scope here.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  hashContent,
+  formatBunLog,
+  getLocalizedOutputPath,
+  getDisplayPath,
+  isCMSPage,
+  buildCMSItemPath,
+  injectTrackingScript,
+  generateRobotsTxt,
+  generateSitemap,
+} from './build-static';
+import type { JSONPage, CMSItem, I18nConfig } from './lib/shared/types';
+
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+const TEST_DIR = join(tmpdir(), `build-static-test-${Date.now()}`);
+
+function createTestDir(): string {
+  const dir = join(TEST_DIR, `sub-${Math.random().toString(36).slice(2, 8)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ============================================================================
+// hashContent
+// ============================================================================
+
+describe('hashContent', () => {
+  test('returns an 8-character hex string', () => {
+    const result = hashContent('hello world');
+    expect(result).toMatch(/^[0-9a-f]{8}$/);
+  });
+
+  test('is deterministic', () => {
+    expect(hashContent('test')).toBe(hashContent('test'));
+  });
+
+  test('different inputs produce different hashes', () => {
+    expect(hashContent('input-a')).not.toBe(hashContent('input-b'));
+  });
+
+  test('handles empty string', () => {
+    const result = hashContent('');
+    expect(result).toMatch(/^[0-9a-f]{8}$/);
+  });
+
+  test('handles unicode content', () => {
+    const result = hashContent('こんにちは世界');
+    expect(result).toMatch(/^[0-9a-f]{8}$/);
+  });
+});
+
+// ============================================================================
+// formatBunLog
+// ============================================================================
+
+describe('formatBunLog', () => {
+  test('formats log with position info', () => {
+    const log = {
+      position: { file: 'src/app.ts', line: 42, column: 10, lineText: 'const x = y;' },
+      message: 'Variable not found'
+    };
+    const result = formatBunLog(log);
+    expect(result).toContain('File: src/app.ts');
+    expect(result).toContain('Line 42:10');
+    expect(result).toContain('const x = y;');
+    expect(result).toContain('Variable not found');
+  });
+
+  test('formats log with message only', () => {
+    const log = { message: 'Something went wrong' };
+    const result = formatBunLog(log);
+    expect(result).toBe('Something went wrong');
+  });
+
+  test('formats log with text property', () => {
+    const log = { text: 'Warning: deprecated function' };
+    const result = formatBunLog(log);
+    expect(result).toBe('Warning: deprecated function');
+  });
+
+  test('falls back to JSON.stringify when no extractable fields', () => {
+    const log = { custom: 'data', nested: { value: 1 } };
+    const result = formatBunLog(log);
+    expect(result).toContain('"custom"');
+    expect(result).toContain('"data"');
+  });
+
+  test('falls back to String() for non-serializable', () => {
+    const circular: any = {};
+    circular.self = circular;
+    // Should not throw
+    const result = formatBunLog(circular);
+    expect(typeof result).toBe('string');
+  });
+
+  test('handles position without lineText', () => {
+    const log = {
+      position: { file: 'index.ts', line: 1 },
+      message: 'Error'
+    };
+    const result = formatBunLog(log);
+    expect(result).toContain('File: index.ts');
+    expect(result).toContain('Line 1:0');
+    expect(result).toContain('Error');
+  });
+});
+
+// ============================================================================
+// getLocalizedOutputPath
+// ============================================================================
+
+describe('getLocalizedOutputPath', () => {
+  const dist = '/project/dist';
+
+  test('root path with default locale', () => {
+    expect(getLocalizedOutputPath('/', 'en', 'en', dist)).toBe('/project/dist/index.html');
+  });
+
+  test('nested path with default locale', () => {
+    expect(getLocalizedOutputPath('/about', 'en', 'en', dist)).toBe('/project/dist/about.html');
+  });
+
+  test('root path with non-default locale', () => {
+    expect(getLocalizedOutputPath('/', 'fr', 'en', dist)).toBe('/project/dist/fr/index.html');
+  });
+
+  test('nested path with non-default locale', () => {
+    expect(getLocalizedOutputPath('/about', 'fr', 'en', dist)).toBe('/project/dist/fr/about.html');
+  });
+
+  test('uses translated slug when available', () => {
+    const slugs = { en: 'about', fr: 'a-propos' };
+    expect(getLocalizedOutputPath('/about', 'fr', 'en', dist, slugs)).toBe('/project/dist/fr/a-propos.html');
+  });
+
+  test('translated slug for default locale', () => {
+    const slugs = { en: 'about-us', fr: 'a-propos' };
+    expect(getLocalizedOutputPath('/about', 'en', 'en', dist, slugs)).toBe('/project/dist/about-us.html');
+  });
+
+  test('falls back to base path when locale has no slug', () => {
+    const slugs = { en: 'about' };
+    expect(getLocalizedOutputPath('/about', 'de', 'en', dist, slugs)).toBe('/project/dist/de/about.html');
+  });
+
+  test('deep nested path with default locale', () => {
+    expect(getLocalizedOutputPath('/blog/post', 'en', 'en', dist)).toBe('/project/dist/blog/post.html');
+  });
+});
+
+// ============================================================================
+// getDisplayPath
+// ============================================================================
+
+describe('getDisplayPath', () => {
+  test('root path with default locale returns /', () => {
+    expect(getDisplayPath('/', 'en', 'en')).toBe('/');
+  });
+
+  test('nested path with default locale', () => {
+    expect(getDisplayPath('/about', 'en', 'en')).toBe('/about');
+  });
+
+  test('root path with non-default locale', () => {
+    expect(getDisplayPath('/', 'fr', 'en')).toBe('/fr');
+  });
+
+  test('nested path with non-default locale', () => {
+    expect(getDisplayPath('/about', 'fr', 'en')).toBe('/fr/about');
+  });
+
+  test('uses translated slug', () => {
+    const slugs = { en: 'about', fr: 'a-propos' };
+    expect(getDisplayPath('/about', 'fr', 'en', slugs)).toBe('/fr/a-propos');
+  });
+
+  test('translated slug for default locale', () => {
+    const slugs = { en: 'about-us', fr: 'a-propos' };
+    expect(getDisplayPath('/about', 'en', 'en', slugs)).toBe('/about-us');
+  });
+
+  test('falls back to base path when slug missing for locale', () => {
+    const slugs = { en: 'about' };
+    expect(getDisplayPath('/about', 'de', 'en', slugs)).toBe('/de/about');
+  });
+});
+
+// ============================================================================
+// isCMSPage
+// ============================================================================
+
+describe('isCMSPage', () => {
+  test('returns true when source is cms and cms config exists', () => {
+    const page = {
+      meta: {
+        source: 'cms',
+        cms: { id: 'blog', urlPattern: '/blog/{{slug}}', slugField: 'slug' }
+      },
+      nodes: []
+    } as unknown as JSONPage;
+    expect(isCMSPage(page)).toBe(true);
+  });
+
+  test('returns false when source is not cms', () => {
+    const page = {
+      meta: { title: 'About' },
+      nodes: []
+    } as unknown as JSONPage;
+    expect(isCMSPage(page)).toBe(false);
+  });
+
+  test('returns false when source is cms but cms config is missing', () => {
+    const page = {
+      meta: { source: 'cms' },
+      nodes: []
+    } as unknown as JSONPage;
+    expect(isCMSPage(page)).toBe(false);
+  });
+
+  test('returns false when meta is missing', () => {
+    const page = { nodes: [] } as unknown as JSONPage;
+    expect(isCMSPage(page)).toBe(false);
+  });
+
+  test('returns false when meta is undefined', () => {
+    const page = { meta: undefined, nodes: [] } as unknown as JSONPage;
+    expect(isCMSPage(page)).toBe(false);
+  });
+});
+
+// ============================================================================
+// buildCMSItemPath
+// ============================================================================
+
+describe('buildCMSItemPath', () => {
+  const defaultI18nConfig: I18nConfig = {
+    defaultLocale: 'en',
+    locales: [{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }]
+  };
+
+  test('replaces {{slug}} with item slug field', () => {
+    const item: CMSItem = { _id: '1', _slug: 'my-post', title: 'My Post' };
+    const result = buildCMSItemPath('/blog/{{slug}}', item, '_slug', 'en', defaultI18nConfig);
+    expect(result).toBe('/blog/my-post');
+  });
+
+  test('uses specified slugField', () => {
+    const item: CMSItem = { _id: '1', _slug: 'fallback', customSlug: 'custom-value', title: 'Test' };
+    const result = buildCMSItemPath('/posts/{{slug}}', item, 'customSlug', 'en', defaultI18nConfig);
+    expect(result).toBe('/posts/custom-value');
+  });
+
+  test('falls back to _slug when slugField is missing', () => {
+    const item: CMSItem = { _id: '1', _slug: 'fallback-slug', title: 'Test' };
+    const result = buildCMSItemPath('/posts/{{slug}}', item, 'nonexistent', 'en', defaultI18nConfig);
+    expect(result).toBe('/posts/fallback-slug');
+  });
+
+  test('falls back to _id when both slugField and _slug are missing', () => {
+    const item: CMSItem = { _id: 'abc123', title: 'Test' };
+    const result = buildCMSItemPath('/items/{{slug}}', item, 'missing', 'en', defaultI18nConfig);
+    expect(result).toBe('/items/abc123');
+  });
+
+  test('handles i18n slug values', () => {
+    const item: CMSItem = {
+      _id: '1',
+      _slug: { _i18n: true, en: 'hello', fr: 'bonjour' },
+      title: 'Test'
+    };
+    const result = buildCMSItemPath('/page/{{slug}}', item, '_slug', 'fr', defaultI18nConfig);
+    expect(result).toBe('/page/bonjour');
+  });
+
+  test('resolves i18n slug for default locale', () => {
+    const item: CMSItem = {
+      _id: '1',
+      _slug: { _i18n: true, en: 'hello', fr: 'bonjour' },
+      title: 'Test'
+    };
+    const result = buildCMSItemPath('/page/{{slug}}', item, '_slug', 'en', defaultI18nConfig);
+    expect(result).toBe('/page/hello');
+  });
+
+  test('handles numeric slug values', () => {
+    const item: CMSItem = { _id: '42', title: 'Test' };
+    const result = buildCMSItemPath('/item/{{slug}}', item, '_id', 'en', defaultI18nConfig);
+    expect(result).toBe('/item/42');
+  });
+});
+
+// ============================================================================
+// injectTrackingScript
+// ============================================================================
+
+describe('injectTrackingScript', () => {
+  test('injects script before </head>', () => {
+    const html = '<html><head><title>Test</title></head><body></body></html>';
+    const script = 'console.log("tracking")';
+    const result = injectTrackingScript(html, script);
+    expect(result).toContain('<script>console.log("tracking")</script>\n</head>');
+  });
+
+  test('preserves existing head content', () => {
+    const html = '<html><head><meta charset="utf-8"><link rel="stylesheet" href="style.css"></head><body></body></html>';
+    const script = 'track()';
+    const result = injectTrackingScript(html, script);
+    expect(result).toContain('<meta charset="utf-8">');
+    expect(result).toContain('<link rel="stylesheet" href="style.css">');
+    expect(result).toContain('<script>track()</script>');
+  });
+
+  test('returns original html if no </head> tag', () => {
+    const html = '<html><body>no head</body></html>';
+    const script = 'track()';
+    const result = injectTrackingScript(html, script);
+    expect(result).toBe(html);
+  });
+});
+
+// ============================================================================
+// generateRobotsTxt
+// ============================================================================
+
+describe('generateRobotsTxt', () => {
+  test('generates robots.txt with correct content', async () => {
+    const dir = createTestDir();
+    await generateRobotsTxt('https://example.com', dir);
+
+    const content = readFileSync(join(dir, 'robots.txt'), 'utf-8');
+    expect(content).toContain('User-agent: *');
+    expect(content).toContain('Allow: /');
+    expect(content).toContain('Sitemap: https://example.com/sitemap.xml');
+  });
+
+  test('uses provided siteUrl in sitemap reference', async () => {
+    const dir = createTestDir();
+    await generateRobotsTxt('https://mysite.dev', dir);
+
+    const content = readFileSync(join(dir, 'robots.txt'), 'utf-8');
+    expect(content).toContain('Sitemap: https://mysite.dev/sitemap.xml');
+  });
+});
+
+// ============================================================================
+// generateSitemap
+// ============================================================================
+
+describe('generateSitemap', () => {
+  test('generates valid XML sitemap', async () => {
+    const dir = createTestDir();
+    const urls = ['/', '/about', '/contact'];
+    await generateSitemap(urls, 'https://example.com', dir);
+
+    const content = readFileSync(join(dir, 'sitemap.xml'), 'utf-8');
+    expect(content).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+    expect(content).toContain('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">');
+    expect(content).toContain('<url><loc>https://example.com/</loc></url>');
+    expect(content).toContain('<url><loc>https://example.com/about</loc></url>');
+    expect(content).toContain('<url><loc>https://example.com/contact</loc></url>');
+  });
+
+  test('sorts URLs for deterministic output', async () => {
+    const dir = createTestDir();
+    const urls = ['/z-page', '/a-page', '/m-page'];
+    await generateSitemap(urls, 'https://example.com', dir);
+
+    const content = readFileSync(join(dir, 'sitemap.xml'), 'utf-8');
+    const aIdx = content.indexOf('/a-page');
+    const mIdx = content.indexOf('/m-page');
+    const zIdx = content.indexOf('/z-page');
+    expect(aIdx).toBeLessThan(mIdx);
+    expect(mIdx).toBeLessThan(zIdx);
+  });
+
+  test('handles empty URL list', async () => {
+    const dir = createTestDir();
+    await generateSitemap([], 'https://example.com', dir);
+
+    const content = readFileSync(join(dir, 'sitemap.xml'), 'utf-8');
+    expect(content).toContain('<urlset');
+    expect(content).toContain('</urlset>');
+    // No <url> entries
+    expect(content).not.toContain('<url>');
+  });
+
+  test('handles single URL', async () => {
+    const dir = createTestDir();
+    await generateSitemap(['/'], 'https://example.com', dir);
+
+    const content = readFileSync(join(dir, 'sitemap.xml'), 'utf-8');
+    expect(content).toContain('<url><loc>https://example.com/</loc></url>');
+  });
+
+  test('does not mutate input array', async () => {
+    const dir = createTestDir();
+    const urls = ['/c', '/a', '/b'];
+    const original = [...urls];
+    await generateSitemap(urls, 'https://example.com', dir);
+    expect(urls).toEqual(original);
+  });
+});
+
+// ============================================================================
+// Cleanup
+// ============================================================================
+
+afterEach(() => {
+  // Cleanup is done per-test via createTestDir
+});

package/build-static.ts

@@ -25,9 +25,11 @@ import { loadProjectConfig } from "./lib/shared/fontLoader";
 import { FileSystemCMSProvider } from "./lib/server/providers/fileSystemCMSProvider";
 import { CMSService } from "./lib/server/services/cmsService";
 import { isI18nValue, resolveI18nValue } from "./lib/shared/i18n";
-import type { ComponentDefinition, JSONPage, CMSSchema, CMSItem, I18nConfig } from "./lib/shared/types";
+import type { ComponentDefinition, JSONPage, CMSSchema, CMSItem, I18nConfig, Experiment } from "./lib/shared/types";
 import type { SlugMap } from "./lib/shared/slugTranslator";
 import { buildItemUrl } from "./lib/shared/itemTemplateUtils";
+import { generateMiddleware, generateTrackFunction, generateResultsFunction } from "./lib/server/ab/generateFunctions";
+import { generateTrackingScript } from "./lib/server/ab/trackingScript";
 
 /**
  * Collect build errors for error overlay
@@ -37,14 +39,14 @@ const buildErrors: BuildError[] = [];
 /**
  * Generate short hash from content for file naming
  */
-function hashContent(content: string): string {
+export function hashContent(content: string): string {
   return createHash('sha256').update(content).digest('hex').slice(0, 8);
 }
 
 /**
  * Format a Bun build log entry to a readable string
  */
-function formatBunLog(log: any): string {
+export function formatBunLog(log: any): string {
   const parts: string[] = [];
 
   // Try to get position info
@@ -205,7 +207,7 @@ function copyDirectory(src: string, dest: string): void {
  * Default locale files go to root, other locales to subdirectories
  * Uses translated slugs from meta.slugs if available
  */
-function getLocalizedOutputPath(
+export function getLocalizedOutputPath(
   basePath: string,
   locale: string,
   defaultLocale: string,
@@ -234,7 +236,7 @@ function getLocalizedOutputPath(
 /**
  * Get display path for logging (the actual URL the user will visit)
  */
-function getDisplayPath(
+export function getDisplayPath(
   basePath: string,
   locale: string,
   defaultLocale: string,
@@ -259,7 +261,7 @@ function getDisplayPath(
 /**
  * Generate robots.txt with sensible defaults
  */
-async function generateRobotsTxt(siteUrl: string, distDir: string): Promise<void> {
+export async function generateRobotsTxt(siteUrl: string, distDir: string): Promise<void> {
   const content = `User-agent: *
 Allow: /
 
@@ -271,7 +273,7 @@ Sitemap: ${siteUrl}/sitemap.xml
 /**
  * Generate sitemap.xml from collected URLs
  */
-async function generateSitemap(urls: string[], siteUrl: string, distDir: string): Promise<void> {
+export async function generateSitemap(urls: string[], siteUrl: string, distDir: string): Promise<void> {
   // Sort URLs for deterministic output
   const sortedUrls = [...urls].sort();
 
@@ -301,11 +303,12 @@ function cleanDist(): void {
   let cleaned = 0;
 
   for (const file of files) {
-    // Keep fonts, images, and icons
+    // Keep fonts, images, icons, and assets
     if (
       file === "fonts" ||
       file === "images" ||
-      file === "icons"
+      file === "icons" ||
+      file === "assets"
     ) {
       continue;
     }
@@ -334,7 +337,7 @@ function cleanDist(): void {
 /**
  * Check if a page is a CMS template
  */
-function isCMSPage(pageData: JSONPage): boolean {
+export function isCMSPage(pageData: JSONPage): boolean {
   return pageData.meta?.source === 'cms' && !!pageData.meta?.cms;
 }
 
@@ -342,7 +345,7 @@ function isCMSPage(pageData: JSONPage): boolean {
  * Build URL path for a CMS item based on the URL pattern
  * Uses schema.slugField to get the slug value, supporting i18n slugs
  */
-function buildCMSItemPath(
+export function buildCMSItemPath(
   urlPattern: string,
   item: CMSItem,
   slugField: string,
@@ -395,7 +398,8 @@ async function buildCMSTemplates(
   cmsService: CMSService,
   generatedUrls: Set<string>,
   staticCollections: Map<string, ClientDataCollection>,
-  siteUrl?: string
+  siteUrl?: string,
+  abTrackingScript?: string | null
 ): Promise<{ success: number; errors: number }> {
   let successCount = 0;
   let errorCount = 0;
@@ -493,6 +497,11 @@ async function buildCMSTemplates(
             finalHtml = finalHtml.replace('</body>', `  <script src="${scriptPath}" defer></script>\n</body>`);
           }
 
+          // Inject A/B tracking script if experiments are running
+          if (abTrackingScript) {
+            finalHtml = injectTrackingScript(finalHtml, abTrackingScript);
+          }
+
           const outputPath = locale === i18nConfig.defaultLocale
             ? `${distDir}${itemPath}.html`
             : `${distDir}/${locale}${itemPath}.html`;
@@ -568,6 +577,59 @@ async function buildCMSTemplates(
   return { success: successCount, errors: errorCount };
 }
 
+/**
+ * Load running experiments from experiments.json
+ */
+async function loadRunningExperiments(): Promise<Experiment[]> {
+  const experimentsPath = join(projectPaths.project, 'experiments.json');
+  if (!existsSync(experimentsPath)) return [];
+
+  try {
+    const content = await readFile(experimentsPath, 'utf-8');
+    const data = JSON.parse(content);
+    const experiments: Experiment[] = data.experiments || [];
+    return experiments.filter(e => e.status === 'running');
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Inject A/B tracking script into HTML before </head>
+ */
+export function injectTrackingScript(html: string, trackingJs: string): string {
+  const scriptTag = `<script>${trackingJs}</script>`;
+  return html.replace('</head>', `${scriptTag}\n</head>`);
+}
+
+/**
+ * Generate A/B testing Cloudflare Functions into dist/functions/
+ */
+async function generateABFunctions(experiments: Experiment[], distDir: string): Promise<void> {
+  // Generate middleware
+  const middlewareContent = generateMiddleware(experiments);
+  if (middlewareContent) {
+    const middlewarePath = join(distDir, 'functions', '_middleware.ts');
+    const middlewareDir = join(distDir, 'functions');
+    if (!existsSync(middlewareDir)) {
+      mkdirSync(middlewareDir, { recursive: true });
+    }
+    await writeFile(middlewarePath, middlewareContent, 'utf-8');
+  }
+
+  // Generate tracking endpoint
+  const trackContent = generateTrackFunction();
+  const trackDir = join(distDir, 'functions', 'api');
+  if (!existsSync(trackDir)) {
+    mkdirSync(trackDir, { recursive: true });
+  }
+  await writeFile(join(trackDir, 'ab-track.ts'), trackContent, 'utf-8');
+
+  // Generate results endpoint
+  const resultsContent = generateResultsFunction();
+  await writeFile(join(trackDir, 'ab-results.ts'), resultsContent, 'utf-8');
+}
+
 /**
  * Main build function
  */
@@ -589,6 +651,15 @@ export async function buildStaticPages(): Promise<void> {
   // Track all generated URLs for sitemap
   const generatedUrls = new Set<string>();
 
+  // Load running A/B experiments (if any)
+  const runningExperiments = await loadRunningExperiments();
+  let trackingScript: string | null = null;
+  if (runningExperiments.length > 0) {
+    const exp = runningExperiments[0]; // Use first running experiment
+    trackingScript = generateTrackingScript(exp.id, exp.conversionGoals);
+    console.log(`🧪 A/B experiment active: "${exp.name}" (${exp.variants.length} variant(s))\n`);
+  }
+
   // Load i18n config for multi-locale build
   const i18nConfig = await loadI18nConfig();
   console.log(`🌐 Locales: ${i18nConfig.locales.map(l => l.code).join(", ")} (default: ${i18nConfig.defaultLocale})\n`);
@@ -612,6 +683,7 @@ export async function buildStaticPages(): Promise<void> {
   copyDirectory(projectPaths.fonts(), join(distDir, "fonts"));
   copyDirectory(projectPaths.images(), join(distDir, "images"));
   copyDirectory(projectPaths.icons(), join(distDir, "icons"));
+  copyDirectory(projectPaths.assets(), join(distDir, "assets"));
 
   // Copy libraries folder (downloaded external JS/CSS files)
   const librariesDir = join(projectPaths.project, "libraries");
@@ -794,6 +866,11 @@ export async function buildStaticPages(): Promise<void> {
           finalHtml = finalHtml.replace('</body>', `  <script src="${scriptPath}" defer></script>\n</body>`);
         }
 
+        // Inject A/B tracking script if experiments are running
+        if (trackingScript) {
+          finalHtml = injectTrackingScript(finalHtml, trackingScript);
+        }
+
         // Determine locale-specific output path with translated slug
         const outputPath = getLocalizedOutputPath(basePath, locale, i18nConfig.defaultLocale, distDir, slugs);
 
@@ -882,7 +959,8 @@ export async function buildStaticPages(): Promise<void> {
     cmsService,
     generatedUrls,
     staticCollections,
-    siteUrl
+    siteUrl,
+    trackingScript
   );
   successCount += cmsResult.success;
   errorCount += cmsResult.errors;
@@ -890,6 +968,12 @@ export async function buildStaticPages(): Promise<void> {
   // Generate static data files for collections with 'static' strategy
   await generateStaticDataFiles(staticCollections, distDir);
 
+  // Generate A/B testing functions if experiments are running
+  if (runningExperiments.length > 0) {
+    await generateABFunctions(runningExperiments, distDir);
+    console.log(`\n🧪 A/B testing functions generated (middleware, tracker, results API)`);
+  }
+
   // Generate SEO files (robots.txt and sitemap.xml)
   if (siteUrl) {
     await generateRobotsTxt(siteUrl, distDir);
@@ -916,6 +1000,9 @@ export async function buildStaticPages(): Promise<void> {
   if (existsSync(functionsDir)) {
     console.log(`   - functions/ (Cloudflare Pages Functions)`);
   }
+  if (runningExperiments.length > 0) {
+    console.log(`   - A/B testing (middleware + tracking injected)`);
+  }
   if (siteUrl) {
     console.log(`   - robots.txt, sitemap.xml (SEO)`);
   }

package/lib/client/ClientInitializer.ts

@@ -72,6 +72,10 @@ export function initializeClient(options: ClientInitOptions = {}): ClientService
     prefetchService,
     // Provide page name getter for interactive styles class generation
     getCurrentPageName: getPageNameFromPath,
+    getCurrentPagePath: () => {
+      if (typeof window === 'undefined') return '/';
+      return window.location.pathname;
+    },
   });
 
   const styleInjector = new StyleInjector({