import { test, expect } from '@playwright/test';

test.describe('Quality - homepage', () => {
  test('homepage: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('homepage: images load correctly', async ({ page }) => {
    await page.goto('/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('homepage: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('homepage: images have alt attributes', async ({ page }) => {
    await page.goto('/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - blog', () => {
  test('blog: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/blog/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('blog: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/blog/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('blog: images have alt attributes', async ({ page }) => {
    await page.goto('/blog/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - brand', () => {
  test('brand: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/brand/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('brand: images load correctly', async ({ page }) => {
    await page.goto('/brand/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('brand: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/brand/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('brand: images have alt attributes', async ({ page }) => {
    await page.goto('/brand/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - build_uis_that_dont_suck', () => {
  test('build_uis_that_dont_suck: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/build-uis-that-dont-suck/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('build_uis_that_dont_suck: images load correctly', async ({ page }) => {
    await page.goto('/build-uis-that-dont-suck/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('build_uis_that_dont_suck: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/build-uis-that-dont-suck/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('build_uis_that_dont_suck: images have alt attributes', async ({ page }) => {
    await page.goto('/build-uis-that-dont-suck/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs', () => {
  test('docs: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - plus', () => {
  test('plus: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/plus/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('plus: images load correctly', async ({ page }) => {
    await page.goto('/plus/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('plus: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/plus/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('plus: images have alt attributes', async ({ page }) => {
    await page.goto('/plus/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - plus_templates', () => {
  test('plus_templates: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/plus/templates/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('plus_templates: images load correctly', async ({ page }) => {
    await page.goto('/plus/templates/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('plus_templates: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/plus/templates/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('plus_templates: images have alt attributes', async ({ page }) => {
    await page.goto('/plus/templates/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - plus_ui_blocks', () => {
  test('plus_ui_blocks: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/plus/ui-blocks/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('plus_ui_blocks: images load correctly', async ({ page }) => {
    await page.goto('/plus/ui-blocks/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('plus_ui_blocks: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/plus/ui-blocks/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('plus_ui_blocks: images have alt attributes', async ({ page }) => {
    await page.goto('/plus/ui-blocks/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - plus_ui_kit', () => {
  test('plus_ui_kit: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/plus/ui-kit/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('plus_ui_kit: images load correctly', async ({ page }) => {
    await page.goto('/plus/ui-kit/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('plus_ui_kit: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/plus/ui-kit/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('plus_ui_kit: images have alt attributes', async ({ page }) => {
    await page.goto('/plus/ui-kit/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - showcase', () => {
  test('showcase: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/showcase/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('showcase: images load correctly', async ({ page }) => {
    await page.goto('/showcase/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('showcase: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/showcase/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('showcase: images have alt attributes', async ({ page }) => {
    await page.goto('/showcase/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - sponsor', () => {
  test('sponsor: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/sponsor/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('sponsor: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/sponsor/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('sponsor: images have alt attributes', async ({ page }) => {
    await page.goto('/sponsor/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_accent_color', () => {
  test('docs_accent_color: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/accent-color/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_accent_color: images load correctly', async ({ page }) => {
    await page.goto('/docs/accent-color/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_accent_color: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/accent-color/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_accent_color: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/accent-color/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_adding_custom_styles', () => {
  test('docs_adding_custom_styles: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/adding-custom-styles/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_adding_custom_styles: images load correctly', async ({ page }) => {
    await page.goto('/docs/adding-custom-styles/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_adding_custom_styles: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/adding-custom-styles/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_adding_custom_styles: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/adding-custom-styles/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_align_content', () => {
  test('docs_align_content: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/align-content/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_align_content: images load correctly', async ({ page }) => {
    await page.goto('/docs/align-content/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_align_content: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/align-content/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_align_content: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/align-content/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_animation', () => {
  test('docs_animation: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/animation/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_animation: images load correctly', async ({ page }) => {
    await page.goto('/docs/animation/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_animation: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/animation/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_animation: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/animation/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_appearance', () => {
  test('docs_appearance: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/appearance/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_appearance: images load correctly', async ({ page }) => {
    await page.goto('/docs/appearance/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_appearance: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/appearance/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_appearance: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/appearance/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_backface_visibility', () => {
  test('docs_backface_visibility: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/backface-visibility/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_backface_visibility: images load correctly', async ({ page }) => {
    await page.goto('/docs/backface-visibility/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_backface_visibility: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/backface-visibility/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_backface_visibility: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/backface-visibility/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_attachment', () => {
  test('docs_background_attachment: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-attachment/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_attachment: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-attachment/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_attachment: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-attachment/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_attachment: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-attachment/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_blend_mode', () => {
  test('docs_background_blend_mode: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-blend-mode/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_blend_mode: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-blend-mode/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_blend_mode: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-blend-mode/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_blend_mode: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-blend-mode/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_clip', () => {
  test('docs_background_clip: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-clip/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_clip: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-clip/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_clip: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-clip/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_clip: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-clip/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_color', () => {
  test('docs_background_color: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-color/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_color: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-color/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_color: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-color/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_color: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-color/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_image', () => {
  test('docs_background_image: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-image/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_image: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-image/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_image: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-image/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_image: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-image/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_origin', () => {
  test('docs_background_origin: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-origin/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_origin: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-origin/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_origin: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-origin/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_origin: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-origin/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_repeat', () => {
  test('docs_background_repeat: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-repeat/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_repeat: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-repeat/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_repeat: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-repeat/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_repeat: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-repeat/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_background_size', () => {
  test('docs_background_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/background-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_background_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/background-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_background_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/background-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_background_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/background-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_block_size', () => {
  test('docs_block_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/block-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_block_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/block-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_block_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/block-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_block_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/block-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_collapse', () => {
  test('docs_border_collapse: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-collapse/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_collapse: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-collapse/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_collapse: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-collapse/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_collapse: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-collapse/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_color', () => {
  test('docs_border_color: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-color/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_color: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-color/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_color: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-color/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_color: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-color/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_radius', () => {
  test('docs_border_radius: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-radius/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_radius: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-radius/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_radius: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-radius/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_radius: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-radius/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_spacing', () => {
  test('docs_border_spacing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-spacing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_spacing: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-spacing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_spacing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-spacing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_spacing: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-spacing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_style', () => {
  test('docs_border_style: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-style/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_style: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-style/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_style: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-style/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_style: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-style/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_border_width', () => {
  test('docs_border_width: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/border-width/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_border_width: images load correctly', async ({ page }) => {
    await page.goto('/docs/border-width/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_border_width: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/border-width/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_border_width: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/border-width/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_box_decoration_break', () => {
  test('docs_box_decoration_break: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/box-decoration-break/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_box_decoration_break: images load correctly', async ({ page }) => {
    await page.goto('/docs/box-decoration-break/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_box_decoration_break: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/box-decoration-break/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_box_decoration_break: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/box-decoration-break/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_box_shadow', () => {
  test('docs_box_shadow: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/box-shadow/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_box_shadow: images load correctly', async ({ page }) => {
    await page.goto('/docs/box-shadow/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_box_shadow: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/box-shadow/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_box_shadow: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/box-shadow/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_box_sizing', () => {
  test('docs_box_sizing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/box-sizing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_box_sizing: images load correctly', async ({ page }) => {
    await page.goto('/docs/box-sizing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_box_sizing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/box-sizing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_box_sizing: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/box-sizing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_break_after', () => {
  test('docs_break_after: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/break-after/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_break_after: images load correctly', async ({ page }) => {
    await page.goto('/docs/break-after/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_break_after: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/break-after/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_break_after: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/break-after/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_break_before', () => {
  test('docs_break_before: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/break-before/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_break_before: images load correctly', async ({ page }) => {
    await page.goto('/docs/break-before/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_break_before: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/break-before/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_break_before: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/break-before/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_break_inside', () => {
  test('docs_break_inside: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/break-inside/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_break_inside: images load correctly', async ({ page }) => {
    await page.goto('/docs/break-inside/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_break_inside: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/break-inside/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_break_inside: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/break-inside/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_caption_side', () => {
  test('docs_caption_side: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/caption-side/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_caption_side: images load correctly', async ({ page }) => {
    await page.goto('/docs/caption-side/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_caption_side: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/caption-side/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_caption_side: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/caption-side/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_caret_color', () => {
  test('docs_caret_color: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/caret-color/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_caret_color: images load correctly', async ({ page }) => {
    await page.goto('/docs/caret-color/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_caret_color: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/caret-color/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_caret_color: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/caret-color/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_color', () => {
  test('docs_color: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/color/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_color: images load correctly', async ({ page }) => {
    await page.goto('/docs/color/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_color: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/color/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_color: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/color/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_color_scheme', () => {
  test('docs_color_scheme: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/color-scheme/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_color_scheme: images load correctly', async ({ page }) => {
    await page.goto('/docs/color-scheme/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_color_scheme: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/color-scheme/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_color_scheme: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/color-scheme/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_colors', () => {
  test('docs_colors: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/colors/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_colors: images load correctly', async ({ page }) => {
    await page.goto('/docs/colors/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_colors: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/colors/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_colors: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/colors/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_compatibility', () => {
  test('docs_compatibility: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/compatibility/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_compatibility: images load correctly', async ({ page }) => {
    await page.goto('/docs/compatibility/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_compatibility: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/compatibility/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_compatibility: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/compatibility/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_content', () => {
  test('docs_content: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/content/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_content: images load correctly', async ({ page }) => {
    await page.goto('/docs/content/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_content: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/content/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_content: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/content/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_cursor', () => {
  test('docs_cursor: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/cursor/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_cursor: images load correctly', async ({ page }) => {
    await page.goto('/docs/cursor/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_cursor: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/cursor/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_cursor: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/cursor/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_dark_mode', () => {
  test('docs_dark_mode: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/dark-mode/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_dark_mode: images load correctly', async ({ page }) => {
    await page.goto('/docs/dark-mode/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_dark_mode: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/dark-mode/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_dark_mode: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/dark-mode/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_detecting_classes_in_source_files', () => {
  test('docs_detecting_classes_in_source_files: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/detecting-classes-in-source-files/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_detecting_classes_in_source_files: images load correctly', async ({ page }) => {
    await page.goto('/docs/detecting-classes-in-source-files/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_detecting_classes_in_source_files: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/detecting-classes-in-source-files/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_detecting_classes_in_source_files: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/detecting-classes-in-source-files/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_editor_setup', () => {
  test('docs_editor_setup: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/editor-setup/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_editor_setup: images load correctly', async ({ page }) => {
    await page.goto('/docs/editor-setup/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_editor_setup: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/editor-setup/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_editor_setup: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/editor-setup/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_field_sizing', () => {
  test('docs_field_sizing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/field-sizing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_field_sizing: images load correctly', async ({ page }) => {
    await page.goto('/docs/field-sizing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_field_sizing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/field-sizing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_field_sizing: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/field-sizing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_filter_drop_shadow', () => {
  test('docs_filter_drop_shadow: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/filter-drop-shadow/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_filter_drop_shadow: images load correctly', async ({ page }) => {
    await page.goto('/docs/filter-drop-shadow/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_filter_drop_shadow: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/filter-drop-shadow/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_filter_drop_shadow: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/filter-drop-shadow/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex', () => {
  test('docs_flex: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex_basis', () => {
  test('docs_flex_basis: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex-basis/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex_basis: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex-basis/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex_basis: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex-basis/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex_basis: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex-basis/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex_direction', () => {
  test('docs_flex_direction: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex-direction/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex_direction: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex-direction/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex_direction: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex-direction/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex_direction: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex-direction/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex_grow', () => {
  test('docs_flex_grow: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex-grow/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex_grow: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex-grow/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex_grow: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex-grow/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex_grow: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex-grow/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex_shrink', () => {
  test('docs_flex_shrink: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex-shrink/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex_shrink: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex-shrink/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex_shrink: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex-shrink/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex_shrink: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex-shrink/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_flex_wrap', () => {
  test('docs_flex_wrap: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/flex-wrap/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_flex_wrap: images load correctly', async ({ page }) => {
    await page.goto('/docs/flex-wrap/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_flex_wrap: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/flex-wrap/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_flex_wrap: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/flex-wrap/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_family', () => {
  test('docs_font_family: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-family/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_family: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-family/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_family: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-family/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_family: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-family/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_feature_settings', () => {
  test('docs_font_feature_settings: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-feature-settings/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_feature_settings: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-feature-settings/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_feature_settings: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-feature-settings/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_feature_settings: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-feature-settings/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_size', () => {
  test('docs_font_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_smoothing', () => {
  test('docs_font_smoothing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-smoothing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_smoothing: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-smoothing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_smoothing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-smoothing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_smoothing: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-smoothing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_stretch', () => {
  test('docs_font_stretch: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-stretch/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_stretch: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-stretch/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_stretch: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-stretch/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_stretch: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-stretch/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_style', () => {
  test('docs_font_style: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-style/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_style: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-style/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_style: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-style/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_style: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-style/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_variant_numeric', () => {
  test('docs_font_variant_numeric: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-variant-numeric/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_variant_numeric: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-variant-numeric/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_variant_numeric: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-variant-numeric/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_variant_numeric: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-variant-numeric/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_font_weight', () => {
  test('docs_font_weight: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/font-weight/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_font_weight: images load correctly', async ({ page }) => {
    await page.goto('/docs/font-weight/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_font_weight: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/font-weight/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_font_weight: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/font-weight/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_gap', () => {
  test('docs_gap: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/gap/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_gap: images load correctly', async ({ page }) => {
    await page.goto('/docs/gap/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_gap: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/gap/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_gap: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/gap/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_auto_columns', () => {
  test('docs_grid_auto_columns: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-auto-columns/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_auto_columns: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-auto-columns/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_auto_columns: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-auto-columns/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_auto_columns: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-auto-columns/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_auto_flow', () => {
  test('docs_grid_auto_flow: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-auto-flow/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_auto_flow: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-auto-flow/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_auto_flow: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-auto-flow/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_auto_flow: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-auto-flow/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_auto_rows', () => {
  test('docs_grid_auto_rows: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-auto-rows/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_auto_rows: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-auto-rows/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_auto_rows: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-auto-rows/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_auto_rows: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-auto-rows/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_column', () => {
  test('docs_grid_column: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-column/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_column: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-column/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_column: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-column/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_column: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-column/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_row', () => {
  test('docs_grid_row: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-row/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_row: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-row/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_row: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-row/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_row: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-row/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_template_columns', () => {
  test('docs_grid_template_columns: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-template-columns/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_template_columns: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-template-columns/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_template_columns: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-template-columns/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_template_columns: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-template-columns/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_grid_template_rows', () => {
  test('docs_grid_template_rows: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/grid-template-rows/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_grid_template_rows: images load correctly', async ({ page }) => {
    await page.goto('/docs/grid-template-rows/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_grid_template_rows: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/grid-template-rows/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_grid_template_rows: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/grid-template-rows/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_height', () => {
  test('docs_height: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/height/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_height: images load correctly', async ({ page }) => {
    await page.goto('/docs/height/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_height: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/height/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_height: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/height/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_hyphens', () => {
  test('docs_hyphens: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/hyphens/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_hyphens: images load correctly', async ({ page }) => {
    await page.goto('/docs/hyphens/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_hyphens: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/hyphens/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_hyphens: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/hyphens/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_inline_size', () => {
  test('docs_inline_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/inline-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_inline_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/inline-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_inline_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/inline-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_inline_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/inline-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_installation', () => {
  test('docs_installation: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/installation/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_installation: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/installation/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_installation: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/installation/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_isolation', () => {
  test('docs_isolation: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/isolation/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_isolation: images load correctly', async ({ page }) => {
    await page.goto('/docs/isolation/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_isolation: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/isolation/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_isolation: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/isolation/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_justify_content', () => {
  test('docs_justify_content: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/justify-content/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_justify_content: images load correctly', async ({ page }) => {
    await page.goto('/docs/justify-content/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_justify_content: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/justify-content/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_justify_content: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/justify-content/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_justify_items', () => {
  test('docs_justify_items: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/justify-items/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_justify_items: images load correctly', async ({ page }) => {
    await page.goto('/docs/justify-items/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_justify_items: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/justify-items/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_justify_items: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/justify-items/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_justify_self', () => {
  test('docs_justify_self: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/justify-self/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_justify_self: images load correctly', async ({ page }) => {
    await page.goto('/docs/justify-self/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_justify_self: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/justify-self/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_justify_self: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/justify-self/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_letter_spacing', () => {
  test('docs_letter_spacing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/letter-spacing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_letter_spacing: images load correctly', async ({ page }) => {
    await page.goto('/docs/letter-spacing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_letter_spacing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/letter-spacing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_letter_spacing: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/letter-spacing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_line_height', () => {
  test('docs_line_height: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/line-height/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_line_height: images load correctly', async ({ page }) => {
    await page.goto('/docs/line-height/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_line_height: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/line-height/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_line_height: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/line-height/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_list_style_image', () => {
  test('docs_list_style_image: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/list-style-image/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_list_style_image: images load correctly', async ({ page }) => {
    await page.goto('/docs/list-style-image/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_list_style_image: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/list-style-image/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_list_style_image: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/list-style-image/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_list_style_position', () => {
  test('docs_list_style_position: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/list-style-position/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_list_style_position: images load correctly', async ({ page }) => {
    await page.goto('/docs/list-style-position/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_list_style_position: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/list-style-position/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_list_style_position: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/list-style-position/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_list_style_type', () => {
  test('docs_list_style_type: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/list-style-type/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_list_style_type: images load correctly', async ({ page }) => {
    await page.goto('/docs/list-style-type/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_list_style_type: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/list-style-type/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_list_style_type: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/list-style-type/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_margin', () => {
  test('docs_margin: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/margin/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_margin: images load correctly', async ({ page }) => {
    await page.goto('/docs/margin/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_margin: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/margin/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_margin: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/margin/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_max_block_size', () => {
  test('docs_max_block_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/max-block-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_max_block_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/max-block-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_max_block_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/max-block-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_max_block_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/max-block-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_max_height', () => {
  test('docs_max_height: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/max-height/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_max_height: images load correctly', async ({ page }) => {
    await page.goto('/docs/max-height/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_max_height: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/max-height/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_max_height: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/max-height/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_min_block_size', () => {
  test('docs_min_block_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/min-block-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_min_block_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/min-block-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_min_block_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/min-block-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_min_block_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/min-block-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_min_height', () => {
  test('docs_min_height: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/min-height/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_min_height: images load correctly', async ({ page }) => {
    await page.goto('/docs/min-height/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_min_height: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/min-height/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_min_height: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/min-height/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_min_inline_size', () => {
  test('docs_min_inline_size: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/min-inline-size/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_min_inline_size: images load correctly', async ({ page }) => {
    await page.goto('/docs/min-inline-size/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_min_inline_size: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/min-inline-size/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_min_inline_size: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/min-inline-size/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_min_width', () => {
  test('docs_min_width: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/min-width/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_min_width: images load correctly', async ({ page }) => {
    await page.goto('/docs/min-width/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_min_width: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/min-width/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_min_width: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/min-width/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_order', () => {
  test('docs_order: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/order/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_order: images load correctly', async ({ page }) => {
    await page.goto('/docs/order/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_order: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/order/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_order: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/order/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_overscroll_behavior', () => {
  test('docs_overscroll_behavior: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/overscroll-behavior/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_overscroll_behavior: images load correctly', async ({ page }) => {
    await page.goto('/docs/overscroll-behavior/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_overscroll_behavior: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/overscroll-behavior/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_overscroll_behavior: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/overscroll-behavior/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_padding', () => {
  test('docs_padding: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/padding/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_padding: images load correctly', async ({ page }) => {
    await page.goto('/docs/padding/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_padding: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/padding/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_padding: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/padding/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_place_content', () => {
  test('docs_place_content: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/place-content/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_place_content: images load correctly', async ({ page }) => {
    await page.goto('/docs/place-content/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_place_content: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/place-content/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_place_content: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/place-content/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_place_items', () => {
  test('docs_place_items: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/place-items/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_place_items: images load correctly', async ({ page }) => {
    await page.goto('/docs/place-items/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_place_items: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/place-items/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_place_items: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/place-items/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_place_self', () => {
  test('docs_place_self: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/place-self/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_place_self: images load correctly', async ({ page }) => {
    await page.goto('/docs/place-self/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_place_self: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/place-self/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_place_self: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/place-self/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_preflight', () => {
  test('docs_preflight: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/preflight/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_preflight: images load correctly', async ({ page }) => {
    await page.goto('/docs/preflight/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_preflight: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/preflight/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_preflight: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/preflight/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_text_align', () => {
  test('docs_text_align: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/text-align/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_text_align: images load correctly', async ({ page }) => {
    await page.goto('/docs/text-align/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_text_align: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/text-align/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_text_align: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/text-align/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_theme', () => {
  test('docs_theme: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/theme/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_theme: images load correctly', async ({ page }) => {
    await page.goto('/docs/theme/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_theme: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/theme/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_theme: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/theme/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_top_right_bottom_left', () => {
  test('docs_top_right_bottom_left: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/top-right-bottom-left/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_top_right_bottom_left: images load correctly', async ({ page }) => {
    await page.goto('/docs/top-right-bottom-left/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_top_right_bottom_left: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/top-right-bottom-left/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_top_right_bottom_left: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/top-right-bottom-left/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_visibility', () => {
  test('docs_visibility: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/visibility/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_visibility: images load correctly', async ({ page }) => {
    await page.goto('/docs/visibility/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_visibility: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/visibility/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_visibility: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/visibility/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_width', () => {
  test('docs_width: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/width/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_width: images load correctly', async ({ page }) => {
    await page.goto('/docs/width/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_width: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/width/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_width: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/width/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - docs_z_index', () => {
  test('docs_z_index: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/docs/z-index/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('docs_z_index: images load correctly', async ({ page }) => {
    await page.goto('/docs/z-index/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('docs_z_index: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/docs/z-index/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('docs_z_index: images have alt attributes', async ({ page }) => {
    await page.goto('/docs/z-index/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - insiders', () => {
  test('insiders: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/insiders/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('insiders: images load correctly', async ({ page }) => {
    await page.goto('/insiders/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('insiders: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/insiders/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('insiders: images have alt attributes', async ({ page }) => {
    await page.goto('/insiders/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - Global', () => {
  test('html has lang attribute', async ({ page }) => {
    await page.goto('/');
    const lang = await page.evaluate(() => document.documentElement.lang);
    expect(lang).toBeTruthy();
  });
});