@jjlmoya/landings 0.4.0

package/src/styles/tokens.css

@@ -0,0 +1,107 @@
+:root {
+    --color-brand-blue: #1ddabc;
+    --color-brand-dark: #000;
+    --color-brand-white: #fff;
+    --color-primary: var(--color-brand-blue);
+    --color-primary-rgb: 29, 218, 188;
+    --color-secondary: #f43f5e;
+    --color-secondary-rgb: 244, 63, 94;
+    --color-blue-tag: #1e40af;
+    --color-wp-blue: #21759b;
+
+    --space-2xs: 0.125rem;
+    --space-xs: 0.25rem;
+    --space-3xs: 0.375rem;
+    --space-sm: 0.5rem;
+    --space-base: 0.75rem;
+    --space-md: 1rem;
+    --space-md-lg: 1.25rem;
+    --space-lg: 1.5rem;
+    --space-xl: 2rem;
+    --space-1-5xl: 2.5rem;
+    --space-2xl: 3rem;
+    --space-2-5xl: 3.75rem;
+    --space-3xl: 4rem;
+    --space-3-5xl: 5rem;
+    --space-4xl: 6rem;
+    --space-5xl: 10rem;
+    --space-6xl: 20rem;
+    --space-max: 32rem;
+
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.1);
+    --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.15);
+    --shadow-lg: 0 10px 25px rgba(0, 0, 0, 0.3);
+    --shadow-xl: 0 25px 50px -12px rgba(0, 0, 0, 0.4);
+    --shadow-light: 0 25px 50px -12px rgba(0, 0, 0, 0.15);
+
+    --radius-sm: 0.375rem;
+    --radius-base: 0.5rem;
+    --radius-md: 0.75rem;
+    --radius-lg: 1rem;
+    --radius-xl: 1.5rem;
+    --radius-2xl: 2.0rem;
+    --radius-full: 9999px;
+
+    --bg-main: var(--color-brand-dark);
+    --bg-surface: #fff;
+    --bg-deep: #0b0f19;
+    --bg-translucent: rgba(0, 0, 0, 0.9);
+    --bg-backdrop: rgba(0, 0, 0, 0.4);
+    --nav-bg: rgba(0, 0, 0, 0.9);
+    --nav-bg-alt: rgba(2, 6, 23, 0.95);
+    --header-bg-light: rgba(248, 250, 252, 0.95);
+
+    --text-main: var(--color-brand-white);
+    --text-muted: #475569;
+    --border-subtle: rgba(29, 218, 188, 0.15);
+    --glass-bg: rgba(255, 255, 255, 0.03);
+    --glass-border: rgba(255, 255, 255, 0.08);
+    --color-accent: #0fa;
+
+    --font-family: 'Inter', sans-serif;
+    --font-weight-light: 300;
+    --font-weight-normal: 400;
+    --font-weight-semibold: 600;
+    --font-weight-bold: 800;
+}
+
+:root,
+.theme-light {
+    --border-base: #e2e8f0;
+    --border-color: #e2e8f0;
+    --bg-main: #f0f4f8;
+    --bg-surface: var(--color-brand-white);
+    --bg-deep: #e2e8f0;
+    --nav-bg: rgba(255, 255, 255, 0.9);
+    --text-main: var(--color-brand-dark);
+    --text-muted: #4a5568;
+    --border-subtle: rgba(230, 230, 230, 0.5);
+    --glass-bg: rgba(0, 0, 0, 0.05);
+    --glass-border: rgba(0, 0, 0, 0.1);
+    --color-accent: #0cb587;
+    --bg-page: #f8fafc;
+    --bg-muted: #f1f5f9;
+    --text-base: #0f172a;
+    --accent: #6366f1;
+    --color-success: #10b981;
+    --color-error: #f43f5e;
+    --color-warning: #f59e0b;
+}
+
+.dark,
+.theme-dark {
+    --bg-main: var(--color-brand-dark);
+    --text-main: var(--color-brand-white);
+    --nav-bg: var(--nav-bg-alt);
+    --bg-surface: #0f172a;
+    --text-muted: #94a3b8;
+    --border-base: #1e293b;
+    --border-color: #1e293b;
+    --bg-page: #020617;
+    --bg-muted: #1e293b;
+    --text-base: #f8fafc;
+    --accent: #818cf8;
+    --color-success: #34d399;
+    --color-error: #fb7185;
+    --color-warning: #fbbf24;
+}

package/src/tests/diacritics_density.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import { normalizeText } from './landing-test-helpers';
+
+type LocaleWithDiacritics = keyof typeof DIACRITIC_RULES;
+
+const DIACRITIC_RULES = {
+    de: { language: 'German', expectedCharacters: 'a umlaut, o umlaut, u umlaut, eszett', characters: /[\u00e4\u00f6\u00fc\u00c4\u00d6\u00dc\u00df]/g, minPerThousandLetters: 0.1 },
+    es: { language: 'Spanish', expectedCharacters: 'accented vowels, u umlaut, enye', characters: /[\u00e1\u00e9\u00ed\u00f3\u00fa\u00fc\u00f1\u00c1\u00c9\u00cd\u00d3\u00da\u00dc\u00d1]/g, minPerThousandLetters: 0.1 },
+    fr: { language: 'French', expectedCharacters: 'French accented letters and ligatures', characters: /[\u00e0\u00e2\u00e6\u00e7\u00e9\u00e8\u00ea\u00eb\u00ee\u00ef\u00f4\u0153\u00f9\u00fb\u00fc\u00ff\u00c0\u00c2\u00c6\u00c7\u00c9\u00c8\u00ca\u00cb\u00ce\u00cf\u00d4\u0152\u00d9\u00db\u00dc\u0178]/g, minPerThousandLetters: 0.1 },
+    it: { language: 'Italian', expectedCharacters: 'Italian accented vowels', characters: /[\u00e0\u00e8\u00e9\u00ec\u00ed\u00ee\u00f2\u00f3\u00f9\u00fa\u00c0\u00c8\u00c9\u00cc\u00cd\u00ce\u00d2\u00d3\u00d9\u00da]/g, minPerThousandLetters: 0.1 },
+    pl: { language: 'Polish', expectedCharacters: 'Polish diacritics', characters: /[\u0105\u0107\u0119\u0142\u0144\u00f3\u015b\u017a\u017c\u0104\u0106\u0118\u0141\u0143\u00d3\u015a\u0179\u017b]/g, minPerThousandLetters: 0.1 },
+    pt: { language: 'Portuguese', expectedCharacters: 'Portuguese accented letters', characters: /[\u00e1\u00e2\u00e3\u00e0\u00e7\u00e9\u00ea\u00ed\u00f3\u00f4\u00f5\u00fa\u00fc\u00c1\u00c2\u00c3\u00c0\u00c7\u00c9\u00ca\u00cd\u00d3\u00d4\u00d5\u00da\u00dc]/g, minPerThousandLetters: 0.1 },
+    sv: { language: 'Swedish', expectedCharacters: 'a ring, a umlaut, o umlaut', characters: /[\u00e5\u00e4\u00f6\u00c5\u00c4\u00d6]/g, minPerThousandLetters: 0.1 },
+    tr: { language: 'Turkish', expectedCharacters: 'Turkish special letters', characters: /[\u00e7\u011f\u0131\u00f6\u015f\u00fc\u00c7\u011e\u0130\u00d6\u015e\u00dc]/g, minPerThousandLetters: 0.1 },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+
+function letterCount(text: string): number {
+    return text.match(LETTERS)?.length ?? 0;
+}
+
+function diacriticCount(text: string, locale: LocaleWithDiacritics): number {
+    return text.match(DIACRITIC_RULES[locale].characters)?.length ?? 0;
+}
+
+function diacriticsPerThousandLetters(text: string, locale: LocaleWithDiacritics): number {
+    const letters = letterCount(text);
+    if (letters === 0) return 0;
+    return diacriticCount(text, locale) / letters * 1000;
+}
+
+describe('Diacritics density validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        describe(`Landing: ${landing.entry.id}`, () => {
+            Object.keys(DIACRITIC_RULES).forEach((locale) => {
+                it(`${locale} keeps the expected accent and special-letter set`, async () => {
+                    const typedLocale = locale as LocaleWithDiacritics;
+                    const loader = landing.entry.i18n[typedLocale];
+                    if (!loader) return;
+
+                    const text = normalizeText(await loader());
+                    const rule = DIACRITIC_RULES[typedLocale];
+                    const letters = letterCount(text);
+                    const matches = diacriticCount(text, typedLocale);
+                    const density = diacriticsPerThousandLetters(text, typedLocale);
+
+                    expect(
+                        density,
+                        [
+                            `Possible spelling or encoding issue detected in ${landing.entry.id}/${typedLocale} (${rule.language}).`,
+                            `The text has ${matches} special characters (${density.toFixed(2)} per 1000 letters, ${letters} letters analyzed).`,
+                            `This locale should include ${rule.expectedCharacters}.`,
+                            'If the count is 0 or near 0, accents, tildes, or special letters were probably stripped by encoding or normalization.',
+                        ].join(' '),
+                    ).toBeGreaterThanOrEqual(rule.minPerThousandLetters);
+                });
+            });
+        });
+    });
+});

package/src/tests/i18n_coverage.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+
+describe('I18n coverage validation', () => {
+    const expectedLocales = Array.from(
+        new Set(ALL_LANDING_DEFINITIONS.flatMap((landing) => Object.keys(landing.entry.i18n))),
+    ).sort();
+
+    ALL_LANDING_DEFINITIONS.forEach(({ entry }) => {
+        describe(`Landing: ${entry.id}`, () => {
+            it('should include every locale currently used by landings', () => {
+                const registeredLocales = Object.keys(entry.i18n);
+                expectedLocales.forEach((locale) => {
+                    expect(
+                        registeredLocales,
+                        `Landing "${entry.id}" is missing locale "${locale}"`,
+                    ).toContain(locale);
+                });
+            });
+
+            it('all locale loaders should be functions', () => {
+                expectedLocales.forEach((locale) => {
+                    const loader = entry.i18n[locale as keyof typeof entry.i18n];
+                    expect(
+                        typeof loader,
+                        `Landing "${entry.id}" locale "${locale}" loader is not a function`,
+                    ).toBe('function');
+                });
+            });
+        });
+    });
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import { collectStrings } from './landing-test-helpers';
+
+const INVERTED_PUNCTUATION_LOCALES = {
+    es: {
+        language: 'Spanish',
+        questionStart: '\u00bf',
+        questionEnd: '?',
+        exclamationStart: '\u00a1',
+        exclamationEnd: '!',
+    },
+} as const;
+
+type InvertedPunctuationLocale = keyof typeof INVERTED_PUNCTUATION_LOCALES;
+
+function sentenceStart(text: string, endIndex: number): string {
+    const beforeMark = text.slice(0, endIndex).trimEnd();
+    const boundary = Math.max(
+        beforeMark.lastIndexOf('.'),
+        beforeMark.lastIndexOf(':'),
+        beforeMark.lastIndexOf(';'),
+        beforeMark.lastIndexOf('\n'),
+    );
+
+    return beforeMark.slice(boundary + 1).trimStart();
+}
+
+function findMissingInvertedMarks(text: string, startMark: string, endMark: string): string[] {
+    return [...text.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+        .map((match) => sentenceStart(text, match.index ?? 0))
+        .filter((segment) => segment.length > 0 && !segment.includes(startMark))
+        .map((segment) => `${segment}${endMark}`);
+}
+
+describe('Inverted punctuation validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        describe(`Landing: ${landing.entry.id}`, () => {
+            Object.keys(INVERTED_PUNCTUATION_LOCALES).forEach((locale) => {
+                it(`${locale} uses opening punctuation marks for questions and exclamations`, async () => {
+                    const typedLocale = locale as InvertedPunctuationLocale;
+                    const loader = landing.entry.i18n[typedLocale];
+                    if (!loader) return;
+
+                    const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
+                    const strings = collectStrings(await loader());
+                    const missingQuestions = strings.flatMap((text) =>
+                        findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd),
+                    );
+                    const missingExclamations = strings.flatMap((text) =>
+                        findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd),
+                    );
+                    const failures = [...missingQuestions, ...missingExclamations];
+
+                    expect(
+                        failures,
+                        [
+                            `Missing opening punctuation marks in ${landing.entry.id}/${typedLocale} (${rule.language}).`,
+                            `Questions must use ${rule.questionStart}...${rule.questionEnd} and exclamations must use ${rule.exclamationStart}...${rule.exclamationEnd}.`,
+                            `Examples: ${failures.slice(0, 5).join(' | ')}`,
+                        ].join(' '),
+                    ).toHaveLength(0);
+                });
+            });
+        });
+    });
+});

package/src/tests/landing-test-helpers.ts

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { LandingCardContent, LandingDefinition } from '../types';
+
+export interface LandingLocaleCase {
+    landingId: string;
+    locale: string;
+    content: LandingCardContent;
+}
+
+export interface LandingExportValidationResult {
+    passed: boolean;
+    failures: string[];
+}
+
+export function getFiles(dir: string, extensions?: string[]): string[] {
+    const results: string[] = [];
+    if (!fs.existsSync(dir)) return results;
+
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!['tests', 'node_modules', '.astro'].includes(entry.name)) {
+                results.push(...getFiles(fullPath, extensions));
+            }
+        } else if (!extensions || extensions.some((extension) => entry.name.endsWith(extension))) {
+            results.push(fullPath);
+        }
+    }
+
+    return results;
+}
+
+export function relativePath(filePath: string): string {
+    return path.relative(process.cwd(), filePath).replace(/\\/g, '/');
+}
+
+export function collectStrings(value: unknown): string[] {
+    if (typeof value === 'string') return [value];
+    if (!value || typeof value !== 'object') return [];
+    if (Array.isArray(value)) return value.flatMap(collectStrings);
+    return Object.values(value).flatMap(collectStrings);
+}
+
+export function normalizeText(value: unknown): string {
+    return collectStrings(value).join(' ').normalize('NFC');
+}
+
+export async function landingLocaleCases(landings: LandingDefinition[]): Promise<LandingLocaleCase[]> {
+    const cases: LandingLocaleCase[] = [];
+
+    for (const landing of landings) {
+        for (const [locale, loader] of Object.entries(landing.entry.i18n)) {
+            if (!loader) continue;
+            cases.push({
+                landingId: landing.entry.id,
+                locale,
+                content: await loader(),
+            });
+        }
+    }
+
+    return cases;
+}
+
+export async function validateLandingExports(landings: LandingDefinition[]): Promise<LandingExportValidationResult> {
+    const failures: string[] = [];
+
+    for (const landing of landings) {
+        if (typeof landing.LandingComponent !== 'function') {
+            failures.push(`${landing.entry.id}: LandingComponent is not a function (${typeof landing.LandingComponent})`);
+            continue;
+        }
+
+        try {
+            const result = await landing.LandingComponent();
+            if (!result || typeof result !== 'object') {
+                failures.push(`${landing.entry.id}: LandingComponent import returned invalid result`);
+            }
+        } catch (error) {
+            failures.push(`${landing.entry.id}: LandingComponent execution error - ${error instanceof Error ? error.message : 'unknown'}`);
+        }
+    }
+
+    return {
+        passed: failures.length === 0,
+        failures,
+    };
+}

package/src/tests/landing_exports.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import { validateLandingExports } from './landing-test-helpers';
+
+describe('Landing exports pattern validation', () => {
+    it('all landings should be registered', () => {
+        expect(ALL_LANDING_DEFINITIONS.length).toBeGreaterThan(0);
+    });
+
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        it(`${landing.entry.id}: LandingComponent should be a lazy-loaded function`, () => {
+            expect(typeof landing.LandingComponent).toBe('function');
+            expect(landing.LandingComponent).toBeInstanceOf(Function);
+        });
+
+        it(`${landing.entry.id}: entry should define an i18n map`, () => {
+            expect(landing.entry.id).toBeTruthy();
+            expect(Object.keys(landing.entry.i18n).length).toBeGreaterThan(0);
+        });
+    });
+
+    it('all landing dynamic imports should work', async () => {
+        const result = await validateLandingExports(ALL_LANDING_DEFINITIONS);
+        if (!result.passed) {
+            throw new Error(`Landing export validation failed:\n${result.failures.join('\n')}`);
+        }
+        expect(result.passed).toBe(true);
+    });
+});

package/src/tests/mocks/astro_mock.js

@@ -0,0 +1 @@
+export default {};

package/src/tests/no_en_dash.test.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { getFiles, relativePath } from './landing-test-helpers';
+
+function isContentFile(filePath: string): boolean {
+    return filePath.includes(`${path.sep}i18n${path.sep}`);
+}
+
+const filesToTest = getFiles(path.join(process.cwd(), 'src')).filter(isContentFile);
+const aiTypographyGarbage = [
+    '\u2013',
+    '\u2014',
+    '\u2026',
+    '\u201c',
+    '\u201d',
+    '\u2018',
+    '\u2019',
+    '\u00ab',
+    '\u00bb',
+    '\u200b',
+    '\u201e',
+];
+
+describe('Typography garbage character validation', () => {
+    filesToTest.forEach((filePath) => {
+        const displayPath = relativePath(filePath);
+
+        it(`should not contain typography garbage characters in ${displayPath}`, () => {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const hasAiPatterns = aiTypographyGarbage.some((char) => content.includes(char));
+            expect(hasAiPatterns).toBe(false);
+        });
+
+        it(`should not contain space before colon in ${displayPath}`, () => {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            expect(/ : /.test(content)).toBe(false);
+        });
+
+        it(`should not contain double hyphen in ${displayPath}`, () => {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            expect(content).not.toContain('--');
+        });
+    });
+});

package/src/tests/no_h1_in_components.test.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import { getFiles, relativePath } from './landing-test-helpers';
+
+function h1Count(content: string): number {
+    return content.match(/<h1[\s>]/gi)?.length ?? 0;
+}
+
+function landingFileForFolder(folderName: string): string | undefined {
+    const files = getFiles(`${process.cwd()}\\src\\landing`, ['.astro'])
+        .filter((file) => file.endsWith('\\landing.astro') || file.endsWith('/landing.astro'));
+    return files.find((file) => file.includes(`\\${folderName}\\`) || file.includes(`/${folderName}/`));
+}
+
+describe('Landing H1 validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        it(`${landing.entry.id} should contain exactly one <h1>`, async () => {
+            const enContent = await landing.entry.i18n.en?.();
+            const file = landingFileForFolder(landing.entry.id) ?? (enContent ? landingFileForFolder(enContent.slug) : undefined);
+            if (!file) {
+                throw new Error(`Could not find landing.astro for landing "${landing.entry.id}"`);
+            }
+            const displayPath = relativePath(file);
+            const content = readFileSync(file, 'utf-8');
+
+            expect(
+                h1Count(content),
+                `Landing "${landing.entry.id}" in ${displayPath} must contain exactly one <h1>.`,
+            ).toBe(1);
+        });
+    });
+});

package/src/tests/pagespeed_best_practices.test.ts

@@ -0,0 +1,143 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { relativePath } from './landing-test-helpers';
+
+const landingDir = join(process.cwd(), 'src', 'landing');
+const geometryReads = [
+    'offsetWidth',
+    'offsetHeight',
+    'offsetTop',
+    'offsetLeft',
+    'clientWidth',
+    'clientHeight',
+    'clientTop',
+    'clientLeft',
+    'scrollWidth',
+    'scrollHeight',
+    'scrollTop',
+    'scrollLeft',
+    'getBoundingClientRect',
+    'getClientRects',
+    'computedStyle',
+    'getComputedStyle',
+];
+const domWrites = [
+    '.style.',
+    '.classList.add',
+    '.classList.remove',
+    '.classList.toggle',
+    '.appendChild',
+    '.insertBefore',
+    '.prepend',
+    '.append',
+    '.remove',
+    '.innerHTML',
+    '.textContent',
+    '.setAttribute',
+];
+
+function findFiles(dir: string, extensions: string[]): string[] {
+    const files: string[] = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) files.push(...findFiles(fullPath, extensions));
+        else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(fullPath);
+    }
+    return files;
+}
+
+function findFormControls(content: string, tagName: 'input' | 'select'): RegExpMatchArray[] {
+    return Array.from(content.matchAll(new RegExp(`<${tagName}\\b[^>]*>`, 'gi')));
+}
+
+function attrValue(tag: string, attr: string): string | null {
+    const match = tag.match(new RegExp(`\\b${attr}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{([^}]+)\\})`, 'i'));
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+
+function booleanAttr(tag: string, attr: string): boolean {
+    return new RegExp(`\\b${attr}\\b`, 'i').test(tag);
+}
+
+function hasExplicitLabel(content: string, id: string): boolean {
+    const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return (
+        new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']${escapedId}["'][^>]*>`, 'i').test(content)
+        || new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*\\{${escapedId}\\}[^>]*>`, 'i').test(content)
+    );
+}
+
+function hasWrappingLabel(content: string, tag: RegExpMatchArray): boolean {
+    const index = tag.index ?? content.indexOf(tag[0]);
+    const before = content.slice(0, index);
+    const labelOpen = before.lastIndexOf('<label');
+    const labelClose = before.lastIndexOf('</label>');
+    const nextLabelClose = content.indexOf('</label>', index + tag[0].length);
+    return labelOpen > labelClose && nextLabelClose !== -1;
+}
+
+function hasAccessibleName(content: string, tag: RegExpMatchArray): boolean {
+    const source = tag[0];
+    if (attrValue(source, 'aria-label')) return true;
+    if (attrValue(source, 'aria-labelledby')) return true;
+    const id = attrValue(source, 'id');
+    if (id && hasExplicitLabel(content, id)) return true;
+    return hasWrappingLabel(content, tag);
+}
+
+function isIgnoredInput(tag: string): boolean {
+    const type = attrValue(tag, 'type')?.toLowerCase() ?? 'text';
+    const attributes = `${attrValue(tag, 'style') ?? ''} ${attrValue(tag, 'class') ?? ''}`.toLowerCase();
+    const visuallyHiddenFile = type === 'file' && ['display:none', 'display: none', 'file-input'].some((pattern) => attributes.includes(pattern));
+    return ['hidden', 'button', 'submit', 'reset'].includes(type) || booleanAttr(tag, 'aria-hidden') || visuallyHiddenFile;
+}
+
+function controlFailures(content: string, tagName: 'input' | 'select'): string[] {
+    return findFormControls(content, tagName)
+        .filter((tag) => tagName !== 'input' || !isIgnoredInput(tag[0]))
+        .filter((tag) => !hasAccessibleName(content, tag))
+        .map((tag) => tag[0]);
+}
+
+function hasDomWriteBeforeGeometryRead(content: string): boolean {
+    const normalized = content.replace(/\s+/g, ' ');
+    return domWrites.some((write) => {
+        const writeIndex = normalized.indexOf(write);
+        if (writeIndex === -1) return false;
+        return geometryReads.some((read) => normalized.indexOf(read, writeIndex + write.length) !== -1);
+    });
+}
+
+describe('PageSpeed best-practice guards', () => {
+    const astroLandingFiles = findFiles(landingDir, ['.astro']);
+    const scriptFiles = findFiles(landingDir, ['.astro', '.ts', '.js']);
+
+    astroLandingFiles.forEach((file) => {
+        const displayPath = relativePath(file);
+
+        it(`${displayPath} labels every input with an explicit label`, () => {
+            const content = readFileSync(file, 'utf-8');
+            const failures = controlFailures(content, 'input');
+            expect(failures, `Input controls without label, wrapping label, aria-label or aria-labelledby in ${displayPath}:\n${failures.join('\n')}`).toEqual([]);
+        });
+
+        it(`${displayPath} labels every select with an explicit label`, () => {
+            const content = readFileSync(file, 'utf-8');
+            const failures = controlFailures(content, 'select');
+            expect(failures, `Select controls without label, wrapping label, aria-label or aria-labelledby in ${displayPath}:\n${failures.join('\n')}`).toEqual([]);
+        });
+    });
+
+    scriptFiles.forEach((file) => {
+        const displayPath = relativePath(file);
+
+        it(`${displayPath} avoids static forced-reflow patterns`, () => {
+            const content = readFileSync(file, 'utf-8');
+            expect(
+                hasDomWriteBeforeGeometryRead(content),
+                `${displayPath} appears to read layout geometry after DOM/style mutations. Split writes and reads across frames or measure before mutating.`,
+            ).toBe(false);
+        });
+    });
+});

package/src/tests/script_density.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import { normalizeText } from './landing-test-helpers';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+    ja: { language: 'Japanese', scriptName: 'kana/kanji', scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu, minScriptRatio: 0.45 },
+    ko: { language: 'Korean', scriptName: 'hangul', scriptCharacters: /\p{Script=Hangul}/gu, minScriptRatio: 0.55 },
+    ru: { language: 'Russian', scriptName: 'cyrillic', scriptCharacters: /\p{Script=Cyrillic}/gu, minScriptRatio: 0.65 },
+    zh: { language: 'Chinese', scriptName: 'han', scriptCharacters: /\p{Script=Han}/gu, minScriptRatio: 0.45 },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+
+function letterCount(text: string): number {
+    return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+    return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+    const letters = letterCount(text);
+    if (letters === 0) return 0;
+    return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        describe(`Landing: ${landing.entry.id}`, () => {
+            Object.keys(SCRIPT_RULES).forEach((locale) => {
+                it(`${locale} keeps most translated text in its native script`, async () => {
+                    const typedLocale = locale as ScriptLocale;
+                    const loader = landing.entry.i18n[typedLocale];
+                    if (!loader) return;
+
+                    const rule = SCRIPT_RULES[typedLocale];
+                    const text = normalizeText(await loader());
+                    const letters = letterCount(text);
+                    const matches = scriptCount(text, typedLocale);
+                    const ratio = scriptRatio(text, typedLocale);
+
+                    expect(
+                        ratio,
+                        [
+                            `Possible broken translation detected in ${landing.entry.id}/${typedLocale} (${rule.language}).`,
+                            `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+                            `Most translatable content should be written in ${rule.scriptName} script.`,
+                        ].join(' '),
+                    ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+                });
+            });
+        });
+    });
+});