@wildo-ai/saas-website 1.1.1

package/src/astro/__tests__/website-page-head.renderer.test.ts

@@ -0,0 +1,424 @@
+import { describe, expect, it } from 'vitest';
+
+import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+
+import { WildoMarketingWebsiteConfigSchema } from '../../config/wildo-website-config.schemas';
+import { WebsiteLabelKeySchema } from '../../schemas/label-keys/website-label-key.schemas';
+import {
+  WebsitePageManifestSchema,
+  type WebsitePageManifest,
+} from '../../schemas/manifests/website-page-manifest.shared.schemas';
+import {
+  WebsiteRootConfigSchema,
+  type WebsiteRootConfig,
+} from '../../schemas/manifests/website-root-config.shared.schemas';
+import { WebsitePageRefSchema } from '../../schemas/refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../../schemas/refs/section-ref.schemas';
+import {
+  renderWebsiteDesignTokensCss,
+  renderWebsitePageHeadHtml,
+} from '../website-page-head.renderer';
+import { composeWebsiteSiteContext, type WebsiteSiteContext } from '../website-site-context';
+
+const NoopComponent = () => null;
+
+const COLORS = {
+  background: '#fff',
+  foreground: '#111',
+  primary: '#0070f3',
+  primaryForeground: '#fff',
+  accent: '#ff5e5b',
+  accentForeground: '#fff',
+  surface: '#fafafa',
+  surfaceForeground: '#111',
+  border: '#e5e5e5',
+  muted: '#f5f5f5',
+  mutedForeground: '#737373',
+};
+const RADII = {
+  none: '0',
+  sm: '0.125rem',
+  md: '0.375rem',
+  lg: '0.75rem',
+  xl: '1.5rem',
+  full: '9999px',
+};
+const DESIGN_TOKENS = { colors: COLORS, radii: RADII };
+
+const buildManifest = (
+  ref: string,
+  routePath: string,
+  ogImageUrl?: string,
+  noaiOptOut?: boolean,
+): WebsitePageManifest =>
+  WebsitePageManifestSchema.parse({
+    ref: WebsitePageRefSchema.parse(ref),
+    routePath,
+    pageComponent: NoopComponent,
+    sectionRefs: [WebsiteSectionRefSchema.parse('hero')],
+    metaLabelKeys: {
+      titleKey: WebsiteLabelKeySchema.parse(`website.${ref}.meta.title`),
+      descriptionKey: WebsiteLabelKeySchema.parse(`website.${ref}.meta.description`),
+      ...(ogImageUrl !== undefined ? { ogImageUrl } : {}),
+    },
+    ...(noaiOptOut ? { seo: { noaiOptOut: true } } : {}),
+  }) as WebsitePageManifest;
+
+const DEFAULT_SITE_NAME = 'Example Site';
+const DEFAULT_PUBLIC_ORIGIN = 'https://example.com';
+
+interface BuildSiteContextOverrides {
+  defaultOgImageUrl?: string;
+  siteName?: string;
+  publicOrigin?: string;
+}
+
+const buildSiteContext = (
+  locales: AvailableLanguage[],
+  defaultLocale: AvailableLanguage,
+  manifest: WebsitePageManifest,
+  overrides: BuildSiteContextOverrides = {},
+): WebsiteSiteContext => {
+  const rootConfig = WebsiteRootConfigSchema.parse({
+    pageManifests: [manifest],
+    designTokens: DESIGN_TOKENS,
+    navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+    seo: {
+      siteName: overrides.siteName ?? DEFAULT_SITE_NAME,
+      ...(overrides.defaultOgImageUrl !== undefined
+        ? { defaultOgImageUrl: overrides.defaultOgImageUrl }
+        : {}),
+    },
+    skipToMainContentLabelKey: WebsiteLabelKeySchema.parse(
+      'website.chrome.layout.skip-to-main-content',
+    ),
+  }) as WebsiteRootConfig;
+
+  const websiteConfig = WildoMarketingWebsiteConfigSchema.parse({
+    publicOrigin: overrides.publicOrigin ?? DEFAULT_PUBLIC_ORIGIN,
+    appOrigin: 'https://app.example.com',
+    defaultLocale,
+    locales: locales.map((locale) => ({ locale, path: String(locale) })),
+  });
+
+  return composeWebsiteSiteContext({ rootConfig, websiteConfig });
+};
+
+describe('renderWebsitePageHeadHtml', () => {
+  it('emits title + description + OG/Twitter cards from the resolved label pack', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN, AvailableLanguage.FR],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'Wonder Todos',
+        'website.landing.meta.description': 'Get things done.',
+      },
+    });
+    expect(html).toContain('<title>Wonder Todos</title>');
+    expect(html).toContain('<meta name="description" content="Get things done." />');
+    expect(html).toContain('<meta property="og:title" content="Wonder Todos" />');
+    expect(html).toContain('<meta property="og:description" content="Get things done." />');
+    expect(html).toContain('<meta name="twitter:card" content="summary" />');
+  });
+
+  it('emits OG image + summary_large_image card when ogImageUrl is set', () => {
+    const manifest = buildManifest('landing', '/', 'https://cdn.example.com/og.png');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain(
+      '<meta property="og:image" content="https://cdn.example.com/og.png" />',
+    );
+    expect(html).toContain('<meta name="twitter:card" content="summary_large_image" />');
+  });
+
+  it('emits one ABSOLUTE hreflang link per declared locale plus an x-default fallback', () => {
+    const manifest = buildManifest('pricing', '/pricing');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN, AvailableLanguage.FR, AvailableLanguage.DE],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.pricing.meta.title': 'T',
+        'website.pricing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="en" href="https://example.com/pricing" />',
+    );
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="fr" href="https://example.com/fr/pricing" />',
+    );
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="de" href="https://example.com/de/pricing" />',
+    );
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="x-default" href="https://example.com/pricing" />',
+    );
+  });
+
+  it('builds the locale-prefixed ABSOLUTE hreflang correctly for the root path ("/")', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN, AvailableLanguage.FR],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="en" href="https://example.com/" />',
+    );
+    expect(html).toContain(
+      '<link rel="alternate" hreflang="fr" href="https://example.com/fr" />',
+    );
+  });
+
+  it('emits a <link rel="canonical"> with the absolute URL for the active locale (Phase 6 H-C)', () => {
+    const manifest = buildManifest('pricing', '/pricing');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN, AvailableLanguage.FR],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const enHtml = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.pricing.meta.title': 'T',
+        'website.pricing.meta.description': 'D',
+      },
+    });
+    expect(enHtml).toContain(
+      '<link rel="canonical" href="https://example.com/pricing" />',
+    );
+
+    const frHtml = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.FR,
+      labelPack: {
+        'website.pricing.meta.title': 'T',
+        'website.pricing.meta.description': 'D',
+      },
+    });
+    expect(frHtml).toContain(
+      '<link rel="canonical" href="https://example.com/fr/pricing" />',
+    );
+  });
+
+  it('emits og:url + og:site_name + og:locale + og:locale:alternate (Phase 6 M-A)', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN, AvailableLanguage.FR, AvailableLanguage.DE],
+      AvailableLanguage.EN,
+      manifest,
+      { siteName: 'Wonder Co' },
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain('<meta property="og:url" content="https://example.com/" />');
+    expect(html).toContain('<meta property="og:site_name" content="Wonder Co" />');
+    expect(html).toContain('<meta property="og:locale" content="en" />');
+    expect(html).toContain('<meta property="og:locale:alternate" content="fr" />');
+    expect(html).toContain('<meta property="og:locale:alternate" content="de" />');
+    expect(html).not.toContain('<meta property="og:locale:alternate" content="en" />');
+  });
+
+  it('falls back to seo.defaultOgImageUrl when manifest has no ogImageUrl (Phase 6 M-A)', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+      { defaultOgImageUrl: 'https://cdn.example.com/og-default.png' },
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain(
+      '<meta property="og:image" content="https://cdn.example.com/og-default.png" />',
+    );
+    expect(html).toContain('<meta name="twitter:card" content="summary_large_image" />');
+  });
+
+  it('emits noai robots meta only when the page manifest opts out of AI training', () => {
+    const manifest = buildManifest('pricing', '/pricing', undefined, true);
+    const siteContext = buildSiteContext([AvailableLanguage.EN], AvailableLanguage.EN, manifest);
+    const optedOutHtml = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.pricing.meta.title': 'T',
+        'website.pricing.meta.description': 'D',
+      },
+    });
+    expect(optedOutHtml).toContain('<meta name="robots" content="noai, noimageai" />');
+
+    const defaultManifest = buildManifest('landing', '/');
+    const defaultHtml = renderWebsitePageHeadHtml({
+      manifest: defaultManifest,
+      siteContext: buildSiteContext([AvailableLanguage.EN], AvailableLanguage.EN, defaultManifest),
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(defaultHtml).not.toContain('noai, noimageai');
+  });
+
+  it('per-page ogImageUrl wins over seo.defaultOgImageUrl (precedence rule, Phase 6 M-A)', () => {
+    const manifest = buildManifest('landing', '/', 'https://cdn.example.com/page.png');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+      { defaultOgImageUrl: 'https://cdn.example.com/og-default.png' },
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'T',
+        'website.landing.meta.description': 'D',
+      },
+    });
+    expect(html).toContain(
+      '<meta property="og:image" content="https://cdn.example.com/page.png" />',
+    );
+    expect(html).not.toContain('og-default.png');
+  });
+
+  it('escapes HTML-significant characters in label values to prevent attribute injection', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    const html = renderWebsitePageHeadHtml({
+      manifest,
+      siteContext,
+      locale: AvailableLanguage.EN,
+      labelPack: {
+        'website.landing.meta.title': 'A & B "quoted" <tag>',
+        'website.landing.meta.description': "He's awesome",
+      },
+    });
+    expect(html).toContain(
+      '<title>A &amp; B &quot;quoted&quot; &lt;tag&gt;</title>',
+    );
+    expect(html).toContain(
+      '<meta property="og:title" content="A &amp; B &quot;quoted&quot; &lt;tag&gt;" />',
+    );
+    expect(html).toContain(
+      '<meta name="description" content="He&#39;s awesome" />',
+    );
+  });
+
+  it('throws an actionable error when titleKey is missing from the pack', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    expect(() =>
+      renderWebsitePageHeadHtml({
+        manifest,
+        siteContext,
+        locale: AvailableLanguage.EN,
+        labelPack: {
+          'website.landing.meta.description': 'D',
+        },
+      }),
+    ).toThrow(/Label pack for locale "en" is missing.*page title key.*website\.landing\.meta\.title/s);
+  });
+
+  it('throws an actionable error when descriptionKey is missing from the pack', () => {
+    const manifest = buildManifest('landing', '/');
+    const siteContext = buildSiteContext(
+      [AvailableLanguage.EN],
+      AvailableLanguage.EN,
+      manifest,
+    );
+    expect(() =>
+      renderWebsitePageHeadHtml({
+        manifest,
+        siteContext,
+        locale: AvailableLanguage.EN,
+        labelPack: {
+          'website.landing.meta.title': 'T',
+        },
+      }),
+    ).toThrow(/page description key.*website\.landing\.meta\.description/s);
+  });
+});
+
+describe('renderWebsiteDesignTokensCss', () => {
+  it('emits a :root block with --website-<group>-<token> custom properties', () => {
+    const css = renderWebsiteDesignTokensCss(DESIGN_TOKENS);
+    expect(css).toContain(':root {');
+    expect(css).toContain('--website-colors-primary: #0070f3;');
+    expect(css).toContain('--website-colors-background: #fff;');
+    expect(css).toContain('--website-radii-md: 0.375rem;');
+    expect(css.trim().endsWith('}')).toBe(true);
+  });
+
+  it('emits every declared color + radius token (none silently dropped)', () => {
+    const css = renderWebsiteDesignTokensCss(DESIGN_TOKENS);
+    for (const tokenName of Object.keys(COLORS)) {
+      expect(css).toContain(`--website-colors-${tokenName}:`);
+    }
+    for (const tokenName of Object.keys(RADII)) {
+      expect(css).toContain(`--website-radii-${tokenName}:`);
+    }
+  });
+});

package/src/astro/__tests__/website-page-runtime.helper.test.ts

@@ -0,0 +1,157 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+
+import { WildoMarketingWebsiteConfigSchema } from '../../config/wildo-website-config.schemas';
+import { WebsiteLabelKeySchema } from '../../schemas/label-keys/website-label-key.schemas';
+import {
+  WebsitePageManifestSchema,
+  type WebsitePageManifest,
+} from '../../schemas/manifests/website-page-manifest.shared.schemas';
+import {
+  WebsiteRootConfigSchema,
+  type WebsiteRootConfig,
+} from '../../schemas/manifests/website-root-config.shared.schemas';
+import { WebsitePageRefSchema } from '../../schemas/refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../../schemas/refs/section-ref.schemas';
+import { loadWebsitePageRuntime } from '../website-page-runtime.helper';
+import { composeWebsiteSiteContext, type WebsiteSiteContext } from '../website-site-context';
+
+const NoopComponent = () => null;
+
+const COLORS = {
+  background: '#fff',
+  foreground: '#111',
+  primary: '#0070f3',
+  primaryForeground: '#fff',
+  accent: '#ff5e5b',
+  accentForeground: '#fff',
+  surface: '#fafafa',
+  surfaceForeground: '#111',
+  border: '#e5e5e5',
+  muted: '#f5f5f5',
+  mutedForeground: '#737373',
+};
+const RADII = {
+  none: '0',
+  sm: '0.125rem',
+  md: '0.375rem',
+  lg: '0.75rem',
+  xl: '1.5rem',
+  full: '9999px',
+};
+
+const buildManifest = (): WebsitePageManifest =>
+  WebsitePageManifestSchema.parse({
+    ref: WebsitePageRefSchema.parse('landing'),
+    routePath: '/',
+    pageComponent: NoopComponent,
+    sectionRefs: [WebsiteSectionRefSchema.parse('hero')],
+    metaLabelKeys: {
+      titleKey: WebsiteLabelKeySchema.parse('website.landing.meta.title'),
+      descriptionKey: WebsiteLabelKeySchema.parse('website.landing.meta.description'),
+    },
+  }) as WebsitePageManifest;
+
+const buildRootConfig = (): WebsiteRootConfig =>
+  WebsiteRootConfigSchema.parse({
+    pageManifests: [buildManifest()],
+    designTokens: { colors: COLORS, radii: RADII },
+    navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+    seo: { siteName: 'Example' },
+    skipToMainContentLabelKey: WebsiteLabelKeySchema.parse(
+      'website.chrome.layout.skip-to-main-content',
+    ),
+  }) as WebsiteRootConfig;
+
+const buildSiteContext = (
+  locales: AvailableLanguage[],
+  defaultLocale: AvailableLanguage,
+): WebsiteSiteContext => {
+  const websiteConfig = WildoMarketingWebsiteConfigSchema.parse({
+    publicOrigin: 'https://example.com',
+    appOrigin: 'https://app.example.com',
+    defaultLocale,
+    locales: locales.map((locale) => ({ locale, path: String(locale) })),
+  });
+  return composeWebsiteSiteContext({
+    rootConfig: buildRootConfig(),
+    websiteConfig,
+  });
+};
+
+describe('loadWebsitePageRuntime', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(resolve(tmpdir(), 'website-runtime-helper-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('falls back to defaultLocale when astroLocale is undefined (default-locale path)', () => {
+    writeFileSync(
+      resolve(tmpDir, 'en.json'),
+      JSON.stringify({ 'website.landing.hero.headline': 'EN' }),
+    );
+    const runtime = loadWebsitePageRuntime({
+      manifest: buildManifest(),
+      siteContext: buildSiteContext(
+        [AvailableLanguage.EN, AvailableLanguage.FR],
+        AvailableLanguage.EN,
+      ),
+      labelPacksDir: tmpDir,
+      astroLocale: undefined,
+    });
+    expect(runtime.locale).toBe(AvailableLanguage.EN);
+    expect(runtime.defaultLocale).toBe(AvailableLanguage.EN);
+    expect(runtime.labelPack['website.landing.hero.headline']).toBe('EN');
+  });
+
+  it('uses astroLocale when present and declared on the website config', () => {
+    writeFileSync(
+      resolve(tmpDir, 'fr.json'),
+      JSON.stringify({ 'website.landing.hero.headline': 'FR' }),
+    );
+    const runtime = loadWebsitePageRuntime({
+      manifest: buildManifest(),
+      siteContext: buildSiteContext(
+        [AvailableLanguage.EN, AvailableLanguage.FR],
+        AvailableLanguage.EN,
+      ),
+      labelPacksDir: tmpDir,
+      astroLocale: 'fr',
+    });
+    expect(runtime.locale).toBe(AvailableLanguage.FR);
+    expect(runtime.defaultLocale).toBe(AvailableLanguage.EN);
+    expect(runtime.labelPack['website.landing.hero.headline']).toBe('FR');
+  });
+
+  it('throws an actionable error when astroLocale is not declared on the website config', () => {
+    expect(() =>
+      loadWebsitePageRuntime({
+        manifest: buildManifest(),
+        siteContext: buildSiteContext([AvailableLanguage.EN], AvailableLanguage.EN),
+        labelPacksDir: tmpDir,
+        astroLocale: 'de',
+      }),
+    ).toThrow(/Astro presented locale "de".*declares only \[en\]/s);
+  });
+
+  it('surfaces the underlying loader error when the label pack is missing for the resolved locale', () => {
+    expect(() =>
+      loadWebsitePageRuntime({
+        manifest: buildManifest(),
+        siteContext: buildSiteContext([AvailableLanguage.EN], AvailableLanguage.EN),
+        labelPacksDir: tmpDir,
+        astroLocale: undefined,
+      }),
+    ).toThrow(/Could not read label pack/);
+  });
+});

package/src/astro/__tests__/website-site-context.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest';
+
+import { FrontendProvidersBlockSchema } from '@wildo-ai/saas-models';
+import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+
+import { WildoMarketingWebsiteConfigSchema } from '../../config/wildo-website-config.schemas';
+import { WebsiteLabelKeySchema } from '../../schemas/label-keys/website-label-key.schemas';
+import {
+  WebsitePageManifestSchema,
+  type WebsitePageManifest,
+} from '../../schemas/manifests/website-page-manifest.shared.schemas';
+import {
+  WebsiteRootConfigSchema,
+  type WebsiteRootConfig,
+} from '../../schemas/manifests/website-root-config.shared.schemas';
+import { WebsitePageRefSchema } from '../../schemas/refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../../schemas/refs/section-ref.schemas';
+import { composeWebsiteSiteContext } from '../website-site-context';
+
+const NoopComponent = () => null;
+
+const COLORS = {
+  background: '#fff',
+  foreground: '#111',
+  primary: '#0070f3',
+  primaryForeground: '#fff',
+  accent: '#ff5e5b',
+  accentForeground: '#fff',
+  surface: '#fafafa',
+  surfaceForeground: '#111',
+  border: '#e5e5e5',
+  muted: '#f5f5f5',
+  mutedForeground: '#737373',
+};
+const RADII = {
+  none: '0',
+  sm: '0.125rem',
+  md: '0.375rem',
+  lg: '0.75rem',
+  xl: '1.5rem',
+  full: '9999px',
+};
+
+const buildManifest = (): WebsitePageManifest =>
+  WebsitePageManifestSchema.parse({
+    ref: WebsitePageRefSchema.parse('landing'),
+    routePath: '/',
+    pageComponent: NoopComponent,
+    sectionRefs: [WebsiteSectionRefSchema.parse('hero')],
+    metaLabelKeys: {
+      titleKey: WebsiteLabelKeySchema.parse('website.landing.meta.title'),
+      descriptionKey: WebsiteLabelKeySchema.parse('website.landing.meta.description'),
+    },
+  }) as WebsitePageManifest;
+
+const buildRootConfig = (): WebsiteRootConfig =>
+  WebsiteRootConfigSchema.parse({
+    pageManifests: [buildManifest()],
+    designTokens: { colors: COLORS, radii: RADII },
+    navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+    seo: { siteName: 'Example' },
+    skipToMainContentLabelKey: WebsiteLabelKeySchema.parse(
+      'website.chrome.layout.skip-to-main-content',
+    ),
+  }) as WebsiteRootConfig;
+
+const buildWebsiteConfig = () =>
+  WildoMarketingWebsiteConfigSchema.parse({
+    publicOrigin: 'https://example.com',
+    appOrigin: 'https://app.example.com',
+    defaultLocale: AvailableLanguage.EN,
+    locales: [
+      { locale: AvailableLanguage.EN, path: 'en' },
+      { locale: AvailableLanguage.FR, path: 'fr' },
+    ],
+  });
+
+describe('composeWebsiteSiteContext', () => {
+  it('returns the two source configs by reference under their keyed slots', () => {
+    const rootConfig = buildRootConfig();
+    const websiteConfig = buildWebsiteConfig();
+    const ctx = composeWebsiteSiteContext({ rootConfig, websiteConfig });
+    expect(ctx.rootConfig).toBe(rootConfig);
+    expect(ctx.websiteConfig).toBe(websiteConfig);
+  });
+
+  it('top-level freezes the returned aggregator (defensive guard against in-place mutation)', () => {
+    const ctx = composeWebsiteSiteContext({
+      rootConfig: buildRootConfig(),
+      websiteConfig: buildWebsiteConfig(),
+    });
+    expect(Object.isFrozen(ctx)).toBe(true);
+    expect(() => {
+      (ctx as unknown as { rootConfig: unknown }).rootConfig = {};
+    }).toThrow();
+  });
+
+  it('keeps the optional website frontend provider block by reference', () => {
+    const frontendProviders = FrontendProvidersBlockSchema.parse({
+      providers: {
+        posthog: {
+          metadata: { ref: 'posthog' },
+          providerCapabilities: ['FRONTEND_PRODUCT_ANALYTICS'],
+          protocols: ['FRONTEND_SDK'],
+          publicConfig: {
+            integrationKind: 'product-analytics',
+            websiteRuntime: true,
+          },
+        },
+      },
+    });
+
+    const ctx = composeWebsiteSiteContext({
+      rootConfig: buildRootConfig(),
+      websiteConfig: buildWebsiteConfig(),
+      frontendProviders,
+    });
+
+    expect(ctx.frontendProviders).toBe(frontendProviders);
+  });
+});