@wildo-ai/saas-website 1.1.1

package/src/astro/__tests__/label-pack-loader.test.ts

@@ -0,0 +1,305 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } 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 } 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 {
+  assertLabelPacksValid,
+  loadAllLabelPacks,
+  loadAndValidateAllLabelPacks,
+  loadLabelPack,
+} from '../label-pack-loader';
+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 = () =>
+  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'),
+    },
+  });
+
+const SKIP_KEY_STR = 'website.chrome.layout.skip-to-main-content';
+
+const buildRootConfig = (): WebsiteRootConfig =>
+  WebsiteRootConfigSchema.parse({
+    pageManifests: [buildManifest()],
+    designTokens: { colors: COLORS, radii: RADII },
+    navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+    seo: { siteName: 'Example' },
+    skipToMainContentLabelKey: WebsiteLabelKeySchema.parse(SKIP_KEY_STR),
+  }) as WebsiteRootConfig;
+
+const buildSiteContext = (): WebsiteSiteContext =>
+  composeWebsiteSiteContext({
+    rootConfig: buildRootConfig(),
+    websiteConfig: 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' },
+      ],
+    }),
+  });
+
+const buildExpectedKeys = () => {
+  const map = new Map();
+  map.set(WebsiteSectionRefSchema.parse('hero'), [
+    WebsiteLabelKeySchema.parse('website.landing.hero.headline'),
+  ]);
+  return map;
+};
+
+describe('label-pack-loader', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(resolve(tmpdir(), 'website-label-pack-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('loadLabelPack', () => {
+    it('loads and parses a well-formed pack', () => {
+      writeFileSync(
+        resolve(tmpDir, 'en.json'),
+        JSON.stringify({ 'website.landing.hero.headline': 'Welcome' }),
+      );
+      const pack = loadLabelPack(tmpDir, AvailableLanguage.EN);
+      expect(pack['website.landing.hero.headline']).toBe('Welcome');
+    });
+
+    it('throws an actionable error when the file is missing', () => {
+      expect(() => loadLabelPack(tmpDir, AvailableLanguage.FR)).toThrow(
+        /Could not read label pack.*fr\.json.*locale="fr"/s,
+      );
+    });
+
+    it('throws when JSON is malformed', () => {
+      writeFileSync(resolve(tmpDir, 'en.json'), '{ not json');
+      expect(() => loadLabelPack(tmpDir, AvailableLanguage.EN)).toThrow(
+        /Failed to parse JSON/,
+      );
+    });
+
+    it('throws when the top-level shape is not an object', () => {
+      writeFileSync(resolve(tmpDir, 'en.json'), JSON.stringify(['arr']));
+      expect(() => loadLabelPack(tmpDir, AvailableLanguage.EN)).toThrow(
+        /must contain a JSON object at the top level.*got array/s,
+      );
+    });
+
+    it('throws when a value is not a string', () => {
+      writeFileSync(
+        resolve(tmpDir, 'en.json'),
+        JSON.stringify({ 'website.landing.hero.headline': 42 }),
+      );
+      expect(() => loadLabelPack(tmpDir, AvailableLanguage.EN)).toThrow(
+        /key "website\.landing\.hero\.headline".*must map to a string.*got number/s,
+      );
+    });
+  });
+
+  describe('loadAllLabelPacks', () => {
+    it('loads every locale declared on the website config in declaration order', () => {
+      writeFileSync(
+        resolve(tmpDir, 'en.json'),
+        JSON.stringify({ 'website.landing.hero.headline': 'EN headline' }),
+      );
+      writeFileSync(
+        resolve(tmpDir, 'fr.json'),
+        JSON.stringify({ 'website.landing.hero.headline': 'FR headline' }),
+      );
+      const packs = loadAllLabelPacks(tmpDir, buildSiteContext());
+      expect([...packs.keys()]).toEqual([AvailableLanguage.EN, AvailableLanguage.FR]);
+      expect(packs.get(AvailableLanguage.FR)?.['website.landing.hero.headline']).toBe(
+        'FR headline',
+      );
+    });
+  });
+
+  describe('loadAndValidateAllLabelPacks', () => {
+    it('returns per-locale validation results without throwing on missing keys', () => {
+      writeFileSync(
+        resolve(tmpDir, 'en.json'),
+        JSON.stringify({
+          'website.landing.hero.headline': 'EN',
+          'website.landing.meta.title': 'EN',
+          'website.landing.meta.description': 'EN',
+        }),
+      );
+      writeFileSync(
+        resolve(tmpDir, 'fr.json'),
+        JSON.stringify({
+          'website.landing.meta.title': 'FR',
+        }),
+      );
+      const validations = loadAndValidateAllLabelPacks(
+        tmpDir,
+        buildSiteContext(),
+        buildExpectedKeys(),
+      );
+      expect(validations).toHaveLength(2);
+      const fr = validations.find((v) => v.locale === AvailableLanguage.FR);
+      expect(fr?.result.missing).toEqual(
+        expect.arrayContaining([
+          'website.landing.hero.headline',
+          'website.landing.meta.description',
+        ]),
+      );
+    });
+  });
+
+  describe('assertLabelPacksValid', () => {
+    it('throws on missing keys with the locale tagged in the aggregated message', () => {
+      writeFileSync(
+        resolve(tmpDir, 'en.json'),
+        JSON.stringify({
+          'website.landing.hero.headline': 'EN',
+          'website.landing.meta.title': 'EN',
+          'website.landing.meta.description': 'EN',
+        }),
+      );
+      writeFileSync(resolve(tmpDir, 'fr.json'), JSON.stringify({}));
+      expect(() =>
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys()),
+      ).toThrow(/Locale "fr".*missing 4 required key\(s\)/s);
+    });
+
+    it('annotates each missing key with its declaring page / section origin', () => {
+      writeFileSync(resolve(tmpDir, 'en.json'), JSON.stringify({}));
+      writeFileSync(resolve(tmpDir, 'fr.json'), JSON.stringify({}));
+      let captured: string | undefined;
+      try {
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys());
+      } catch (err) {
+        captured = (err as Error).message;
+      }
+      expect(captured).toBeDefined();
+      expect(captured).toMatch(
+        /"website\.landing\.meta\.title".*page "landing" metaLabelKeys\.titleKey/s,
+      );
+      expect(captured).toMatch(
+        /"website\.landing\.meta\.description".*page "landing" metaLabelKeys\.descriptionKey/s,
+      );
+      expect(captured).toMatch(
+        /"website\.landing\.hero\.headline".*section "hero" in page "landing"/s,
+      );
+    });
+
+    it('aggregates errors across multiple locales in a single throw (not first-fail)', () => {
+      writeFileSync(resolve(tmpDir, 'en.json'), JSON.stringify({}));
+      writeFileSync(resolve(tmpDir, 'fr.json'), JSON.stringify({}));
+      let captured: string | undefined;
+      try {
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys());
+      } catch (err) {
+        captured = (err as Error).message;
+      }
+      expect(captured).toBeDefined();
+      expect(captured).toMatch(/validation failed for 2 locale\(s\)/);
+      expect(captured).toMatch(/Locale "en":/);
+      expect(captured).toMatch(/Locale "fr":/);
+    });
+
+    it('throws on unmappedSectionRefs (build-pipeline bug) inside the aggregated message', () => {
+      writeFileSync(resolve(tmpDir, 'en.json'), JSON.stringify({}));
+      writeFileSync(resolve(tmpDir, 'fr.json'), JSON.stringify({}));
+      const emptyExpected = new Map();
+      expect(() =>
+        assertLabelPacksValid(tmpDir, buildSiteContext(), emptyExpected),
+      ).toThrow(/unmappedSectionRefs.*\[hero\]/s);
+    });
+
+    it('passes with no thrown error when every key is present', () => {
+      const fullPack = JSON.stringify({
+        'website.landing.hero.headline': 'X',
+        'website.landing.meta.title': 'X',
+        'website.landing.meta.description': 'X',
+        [SKIP_KEY_STR]: 'Skip to main content',
+      });
+      writeFileSync(resolve(tmpDir, 'en.json'), fullPack);
+      writeFileSync(resolve(tmpDir, 'fr.json'), fullPack);
+      expect(() =>
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys()),
+      ).not.toThrow();
+    });
+
+    it('warns (not throws) on orphaned keys', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const packWithOrphan = JSON.stringify({
+        'website.landing.hero.headline': 'X',
+        'website.landing.meta.title': 'X',
+        'website.landing.meta.description': 'X',
+        'website.landing.hero.unused-orphan': 'X',
+        [SKIP_KEY_STR]: 'Skip to main content',
+      });
+      writeFileSync(resolve(tmpDir, 'en.json'), packWithOrphan);
+      writeFileSync(resolve(tmpDir, 'fr.json'), packWithOrphan);
+      expect(() =>
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys()),
+      ).not.toThrow();
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringMatching(/orphaned key\(s\).*website\.landing\.hero\.unused-orphan/s),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('treats WebsiteRootConfig.skipToMainContentLabelKey as required (Phase 6 third audit fix M-α)', () => {
+      const partialPack = JSON.stringify({
+        'website.landing.hero.headline': 'X',
+        'website.landing.meta.title': 'X',
+        'website.landing.meta.description': 'X',
+      });
+      writeFileSync(resolve(tmpDir, 'en.json'), partialPack);
+      writeFileSync(resolve(tmpDir, 'fr.json'), partialPack);
+      expect(() =>
+        assertLabelPacksValid(tmpDir, buildSiteContext(), buildExpectedKeys()),
+      ).toThrow(new RegExp(`missing.*"${SKIP_KEY_STR.replace(/\./g, '\\.')}"`, 's'));
+    });
+  });
+});

package/src/astro/__tests__/llms-txt-server.test.ts

@@ -0,0 +1,127 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, 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 { readLlmsTxtBody } from '../llms-txt-server';
+import {
+  composeWebsiteSiteContext,
+  type WebsiteSiteContext,
+} from '../website-site-context';
+
+const NoopComponent = () => null;
+const tempDirs: string[] = [];
+
+function buildManifest(): WebsitePageManifest {
+  return 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;
+}
+
+function buildSiteContext(llmsTxtConfig?: { enabled?: boolean }): WebsiteSiteContext {
+  const rootConfig = WebsiteRootConfigSchema.parse({
+    pageManifests: [buildManifest()],
+    designTokens: {
+      colors: {
+        background: '#fff',
+        foreground: '#111',
+        primary: '#0070f3',
+        primaryForeground: '#fff',
+        accent: '#ff5e5b',
+        accentForeground: '#fff',
+        surface: '#fafafa',
+        surfaceForeground: '#111',
+        border: '#e5e5e5',
+        muted: '#f5f5f5',
+        mutedForeground: '#737373',
+      },
+      radii: {
+        none: '0',
+        sm: '0.125rem',
+        md: '0.375rem',
+        lg: '0.75rem',
+        xl: '1.5rem',
+        full: '9999px',
+      },
+    },
+    navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+    seo: {
+      siteName: 'Example Site',
+      ...(llmsTxtConfig !== undefined ? { llmsTxt: llmsTxtConfig } : {}),
+    },
+    skipToMainContentLabelKey: WebsiteLabelKeySchema.parse(
+      'website.chrome.layout.skip-to-main-content',
+    ),
+  }) as WebsiteRootConfig;
+
+  const websiteConfig = WildoMarketingWebsiteConfigSchema.parse({
+    publicOrigin: 'https://example.com',
+    appOrigin: 'https://app.example.com',
+    defaultLocale: AvailableLanguage.EN,
+    locales: [{ locale: AvailableLanguage.EN, path: 'en' }],
+  });
+
+  return composeWebsiteSiteContext({ rootConfig, websiteConfig });
+}
+
+function makeContentDir(files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), 'wildo-llms-'));
+  tempDirs.push(dir);
+  for (const [fileName, contents] of Object.entries(files)) {
+    writeFileSync(join(dir, fileName), contents, 'utf-8');
+  }
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('readLlmsTxtBody', () => {
+  it('returns the file body when llms.txt exists and publication is auto-detected', () => {
+    const contentDir = makeContentDir({
+      'llms.txt': '# Wonder Todos\n\n- /pricing\n',
+    });
+    expect(readLlmsTxtBody(buildSiteContext(), { contentDir })).toBe('# Wonder Todos\n\n- /pricing\n');
+  });
+
+  it('returns null when llms.txt is absent and publication is auto-detected', () => {
+    const contentDir = makeContentDir({});
+    expect(readLlmsTxtBody(buildSiteContext(), { contentDir })).toBeNull();
+  });
+
+  it('returns null when enabled=false even if the file exists', () => {
+    const contentDir = makeContentDir({
+      'llms.txt': '# Wonder Todos\n',
+    });
+    expect(readLlmsTxtBody(buildSiteContext({ enabled: false }), { contentDir })).toBeNull();
+  });
+
+  it('returns null when enabled=true but the file is absent', () => {
+    const contentDir = makeContentDir({});
+    expect(readLlmsTxtBody(buildSiteContext({ enabled: true }), { contentDir })).toBeNull();
+  });
+});

package/src/astro/__tests__/pick-labels-for-page.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+
+import { WebsiteLabelKeySchema } from '../../schemas/label-keys/website-label-key.schemas';
+import {
+  WebsitePageManifestSchema,
+  type WebsitePageManifest,
+} from '../../schemas/manifests/website-page-manifest.shared.schemas';
+import { WebsitePageRefSchema } from '../../schemas/refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../../schemas/refs/section-ref.schemas';
+import type { LabelPack } from '../../schemas/validators/label-pack.validator';
+import { pickLabelsForPage } from '../pick-labels-for-page';
+
+const NoopComponent = () => null;
+
+const buildLandingManifest = (): 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;
+
+describe('pickLabelsForPage', () => {
+  const fullPack: LabelPack = {
+    'website.landing.meta.title': 'Landing title',
+    'website.landing.hero.headline': 'Landing headline',
+    'website.features.meta.title': 'Features title',
+    'website.features.hero.headline': 'Features headline',
+    'website.pricing.tiers.tier1.name': 'Pricing starter',
+    'website.contact.form.submit': 'Send',
+    'website.chrome.header.brand': 'Acme',
+    'website.chrome.footer.copyright': '© 2026',
+  };
+
+  it("keeps only the page's own slice plus chrome", () => {
+    const filtered = pickLabelsForPage(fullPack, buildLandingManifest());
+    expect(Object.keys(filtered).sort()).toEqual([
+      'website.chrome.footer.copyright',
+      'website.chrome.header.brand',
+      'website.landing.hero.headline',
+      'website.landing.meta.title',
+    ]);
+  });
+
+  it('returns an empty pack when neither the page slice nor any chrome key matches', () => {
+    const minimalPack: LabelPack = { 'website.features.meta.title': 'Features' };
+    const filtered = pickLabelsForPage(minimalPack, buildLandingManifest());
+    expect(filtered).toEqual({});
+  });
+
+  it('does not mutate the input pack', () => {
+    const snapshot = { ...fullPack };
+    pickLabelsForPage(fullPack, buildLandingManifest());
+    expect(fullPack).toEqual(snapshot);
+  });
+});