slidev-theme-practicum 0.3.0 → 0.4.0

package/scripts/check-consumer.mjs

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import {
+  existsSync,
+  lstatSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import process from 'node:process'
+import { chromium } from 'playwright-chromium'
+import { createStaticDistServer, isSameOriginUrl } from './browser-smoke-runtime.mjs'
+
+const PROJECT_ROOT = resolve(import.meta.dirname, '..')
+const CLI_PATH = resolve(PROJECT_ROOT, 'node_modules/@slidev/cli/bin/slidev.mjs')
+const workRoot = mkdtempSync(join(tmpdir(), 'slidev-theme-practicum-consumer-'))
+const packDir = join(workRoot, 'pack')
+const consumerRoot = join(workRoot, 'consumer')
+const consumerDist = join(consumerRoot, 'dist')
+
+function run(command, args, cwd, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: options.env ?? process.env,
+    shell: process.platform === 'win32',
+  })
+
+  assert.equal(
+    result.status,
+    0,
+    `${command} ${args.join(' ')} завершился с кодом ${result.status}\n${result.stderr || result.stdout}`,
+  )
+  return result.stdout
+}
+
+async function inspectConsumerBuild() {
+  const externalRequests = []
+  let browser
+  let server
+
+  try {
+    server = await createStaticDistServer(consumerDist)
+    browser = await chromium.launch({ args: ['--force-color-profile=srgb'] })
+    const context = await browser.newContext({
+      colorScheme: 'light',
+      reducedMotion: 'reduce',
+      serviceWorkers: 'block',
+      viewport: { width: 1280, height: 720 },
+    })
+    const page = await context.newPage()
+    page.on('request', (request) => {
+      if (!isSameOriginUrl(server.origin, request.url()))
+        externalRequests.push(request.url())
+    })
+    await page.goto(`${server.origin}/#/1`, { waitUntil: 'domcontentloaded' })
+    const slide = page.locator('.slidev-page[data-slidev-no="1"]')
+    await slide.waitFor({ state: 'visible' })
+    await page.evaluate(async () => {
+      await document.fonts?.ready
+      await new Promise(resolveFrame => requestAnimationFrame(() => requestAnimationFrame(resolveFrame)))
+    })
+
+    assert.equal(
+      (await slide.locator('h1').textContent())?.replace(/\s+/gu, ' ').trim(),
+      'Тема установлена из архива',
+      'внешняя презентация должна отрисовать содержимое через установленную тему',
+    )
+    assert.equal(
+      await slide.locator('.Slide_layout_cover.Slide_variant_grid').count(),
+      1,
+      'внешняя презентация должна получить layout и variant из архива темы',
+    )
+    for (const assetPath of ['/theme/favicon.svg', '/theme/photos/photo-1.webp']) {
+      const response = await page.request.get(`${server.origin}${assetPath}`)
+      assert.equal(response.status(), 200, `${assetPath} должен попасть во внешнюю сборку`)
+    }
+    assert.deepEqual([...new Set(externalRequests)], [], 'внешняя сборка не должна обращаться в сеть')
+  }
+  finally {
+    await browser?.close()
+    await server?.close()
+  }
+}
+
+try {
+  mkdirSync(packDir, { recursive: true })
+  mkdirSync(consumerRoot, { recursive: true })
+  const packOutput = run('npm', ['pack', '--json', '--pack-destination', packDir], PROJECT_ROOT)
+  const [pack] = JSON.parse(packOutput)
+  const archivePath = join(packDir, pack.filename)
+  assert.equal(existsSync(archivePath), true, 'npm pack должен создать архив темы')
+
+  writeFileSync(join(consumerRoot, 'package.json'), `${JSON.stringify({
+    name: 'slidev-theme-practicum-consumer-check',
+    private: true,
+    type: 'module',
+  }, null, 2)}\n`)
+  writeFileSync(join(consumerRoot, 'slides.md'), `---
+theme: practicum
+title: Проверка установленного архива
+routerMode: hash
+preload: false
+layout: cover
+variant: grid
+mode: dark
+tone: blue
+themeConfig:
+  deckTitle: Проверка установленного архива
+---
+
+<Slot role="primary" surface="dark" margin="4" gap="4">
+  <Text as="h1" size="7">Тема установлена из архива</Text>
+  <Text size="3" align="end" muted>Внешняя презентация собирает layout, компоненты и ресурсы только из упакованной темы.</Text>
+</Slot>
+
+<Slot role="media" surface="color" tone="green" :background="{ src: '/theme/photos/photo-1.webp' }" />
+
+<Slot role="media" surface="dark" :decor="{ meaning: 'cover', tone: 'green' }" />
+
+<Slot role="media" :decor="{ meaning: 'workspace', tone: 'blue' }" />
+`)
+
+  run('npm', [
+    'install',
+    '--prefer-offline',
+    '--ignore-scripts',
+    '--no-audit',
+    '--no-fund',
+    '--no-package-lock',
+    '--no-save',
+    archivePath,
+  ], consumerRoot)
+
+  const installedRoot = join(consumerRoot, 'node_modules/slidev-theme-practicum')
+  assert.equal(lstatSync(installedRoot).isSymbolicLink(), false, 'тема должна быть распакована, а не связана с рабочей копией')
+  assert.ok(
+    realpathSync(installedRoot).startsWith(realpathSync(consumerRoot)),
+    'установленная тема должна находиться внутри внешнего проекта',
+  )
+  const installedManifest = JSON.parse(readFileSync(join(installedRoot, 'package.json'), 'utf8'))
+  const sourceManifest = JSON.parse(readFileSync(join(PROJECT_ROOT, 'package.json'), 'utf8'))
+  assert.equal(installedManifest.version, sourceManifest.version)
+
+  run(process.execPath, [CLI_PATH, 'build', 'slides.md', '--out', consumerDist], consumerRoot)
+  await inspectConsumerBuild()
+  console.log(
+    `Потребитель архива: ${pack.filename}, версия=${installedManifest.version}, `
+    + 'установка=локальный архив, сборка=ok, браузер=ok, внешние запросы=0, ресурсы=2',
+  )
+}
+finally {
+  rmSync(workRoot, { recursive: true, force: true })
+}

package/scripts/check-pixels.mjs

@@ -0,0 +1,251 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { parseSync } from '@slidev/parser'
+import { chromium } from 'playwright-chromium'
+import { createStaticDistServer, isSameOriginUrl } from './browser-smoke-runtime.mjs'
+
+const PROJECT_ROOT = resolve(import.meta.dirname, '..')
+const DIST_DIR = resolve(PROJECT_ROOT, 'dist')
+const DECK_PATH = resolve(PROJECT_ROOT, 'example.md')
+const BASELINE_DIR = resolve(PROJECT_ROOT, 'tests/visual-baselines/example')
+const MANIFEST_PATH = join(BASELINE_DIR, 'manifest.json')
+const UPDATE_BASELINES = process.argv.includes('--update')
+const VIEWPORT = { width: 960, height: 540 }
+const DEVICE_SCALE_FACTOR = 1
+
+function slideFilename(slideNumber) {
+  return `slide-${String(slideNumber).padStart(2, '0')}.png`
+}
+
+function sha256(buffer) {
+  return createHash('sha256').update(buffer).digest('hex')
+}
+
+async function settleSlide(page, slide) {
+  await page.evaluate(async () => {
+    await Promise.race([
+      document.fonts?.ready ?? Promise.resolve(),
+      new Promise(resolveTimeout => setTimeout(resolveTimeout, 3_000)),
+    ])
+  })
+
+  await slide.evaluate(async (root) => {
+    await Promise.all(
+      [...root.querySelectorAll('img')].map(image => image.decode().catch(() => undefined)),
+    )
+
+    await new Promise((resolveStable, rejectStable) => {
+      const timeoutAt = performance.now() + 3_000
+      let previousSignature = ''
+      let stableFrames = 0
+
+      const readSignature = () => [...root.querySelectorAll('.Text')]
+        .map(element => [
+          element.getAttribute('class'),
+          element.clientWidth,
+          element.clientHeight,
+          element.scrollWidth,
+          element.scrollHeight,
+        ].join(':'))
+        .join('|')
+
+      const observeFrame = () => {
+        const signature = readSignature()
+        stableFrames = signature === previousSignature ? stableFrames + 1 : 0
+        previousSignature = signature
+
+        if (stableFrames >= 8) {
+          resolveStable()
+          return
+        }
+
+        if (performance.now() >= timeoutAt) {
+          rejectStable(new Error('Раскладка слайда не стабилизировалась перед снимком.'))
+          return
+        }
+
+        requestAnimationFrame(observeFrame)
+      }
+
+      requestAnimationFrame(observeFrame)
+    })
+  })
+}
+
+async function openSlide(page, origin, slideNumber) {
+  const hash = `#/${slideNumber}`
+
+  if (page.url() === 'about:blank')
+    await page.goto(`${origin}/${hash}`, { waitUntil: 'domcontentloaded' })
+  else {
+    await page.evaluate((nextHash) => {
+      window.location.hash = nextHash
+    }, hash)
+  }
+
+  await page.waitForFunction(expectedHash => window.location.hash === expectedHash, hash)
+  const slide = page.locator(`.slidev-page[data-slidev-no="${slideNumber}"]`)
+  await slide.waitFor({ state: 'visible' })
+  try {
+    await settleSlide(page, slide)
+  }
+  catch (error) {
+    throw new Error(`Слайд ${slideNumber}: ${error.message}`, { cause: error })
+  }
+  return slide
+}
+
+function removeOldBaselines() {
+  if (!existsSync(BASELINE_DIR))
+    return
+
+  for (const file of readdirSync(BASELINE_DIR)) {
+    if (/^slide-\d+\.png$/u.test(file))
+      unlinkSync(join(BASELINE_DIR, file))
+  }
+}
+
+function baselineFiles() {
+  if (!existsSync(BASELINE_DIR))
+    return []
+
+  return readdirSync(BASELINE_DIR)
+    .filter(file => /^slide-\d+\.png$/u.test(file))
+    .sort()
+}
+
+async function run() {
+  const source = readFileSync(DECK_PATH, 'utf8')
+  const slideCount = parseSync(source, DECK_PATH).slides.length
+  const actualDir = join(tmpdir(), `slidev-theme-practicum-pixels-${process.pid}`)
+  const externalRequests = []
+  const screenshots = []
+  let browser
+  let server
+
+  mkdirSync(actualDir, { recursive: true })
+
+  try {
+    server = await createStaticDistServer(DIST_DIR)
+    browser = await chromium.launch({ args: ['--force-color-profile=srgb'] })
+    const context = await browser.newContext({
+      colorScheme: 'light',
+      deviceScaleFactor: DEVICE_SCALE_FACTOR,
+      locale: 'ru-RU',
+      reducedMotion: 'reduce',
+      serviceWorkers: 'block',
+      timezoneId: 'Europe/Moscow',
+      viewport: VIEWPORT,
+    })
+    const page = await context.newPage()
+    page.setDefaultTimeout(15_000)
+    page.on('request', (request) => {
+      if (!isSameOriginUrl(server.origin, request.url()))
+        externalRequests.push(request.url())
+    })
+
+    let fontEnvironment
+    for (let slideNumber = 1; slideNumber <= slideCount; slideNumber += 1) {
+      const slide = await openSlide(page, server.origin, slideNumber)
+      fontEnvironment ??= await slide.evaluate(root => ({
+        cssStack: getComputedStyle(root.querySelector('.slidev-layout')).fontFamily,
+        interAvailable: document.fonts.check('16px "Inter"'),
+        ysTextAvailable: document.fonts.check('16px "YS Text"'),
+      }))
+      const image = await slide.screenshot({
+        animations: 'disabled',
+        caret: 'hide',
+        scale: 'css',
+      })
+      screenshots.push({
+        file: slideFilename(slideNumber),
+        image,
+        sha256: sha256(image),
+      })
+    }
+
+    assert.deepEqual(
+      [...new Set(externalRequests)],
+      [],
+      `Пиксельный контур не должен обращаться во внешнюю сеть: ${externalRequests.join(', ')}`,
+    )
+
+    const environment = {
+      arch: process.arch,
+      chromium: browser.version(),
+      colorProfile: 'srgb',
+      deviceScaleFactor: DEVICE_SCALE_FACTOR,
+      fonts: fontEnvironment,
+      platform: process.platform,
+      slideCount,
+      viewport: VIEWPORT,
+    }
+
+    if (UPDATE_BASELINES) {
+      mkdirSync(BASELINE_DIR, { recursive: true })
+      removeOldBaselines()
+      for (const screenshot of screenshots)
+        writeFileSync(join(BASELINE_DIR, screenshot.file), screenshot.image)
+      writeFileSync(MANIFEST_PATH, `${JSON.stringify({
+        environment,
+        slides: screenshots.map(({ file, sha256: digest }) => ({ file, sha256: digest })),
+      }, null, 2)}\n`)
+      console.log(`Пиксельные эталоны обновлены: ${slideCount} слайдов, Chromium ${environment.chromium}`)
+      return
+    }
+
+    assert.equal(existsSync(MANIFEST_PATH), true, 'Отсутствует manifest пиксельных эталонов. Запустите npm run test:pixels:update.')
+    const manifest = JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'))
+    assert.deepEqual(
+      environment,
+      manifest.environment,
+      'Окружение пиксельной проверки отличается от принятого эталона. Обновите эталоны осознанно.',
+    )
+    assert.deepEqual(
+      baselineFiles(),
+      screenshots.map(({ file }) => file),
+      'Набор PNG-эталонов не соответствует всем слайдам example.md.',
+    )
+
+    const failures = []
+    for (const screenshot of screenshots) {
+      const baselinePath = join(BASELINE_DIR, screenshot.file)
+      const baseline = readFileSync(baselinePath)
+      const expectedDigest = manifest.slides.find(slide => slide.file === screenshot.file)?.sha256
+      assert.equal(sha256(baseline), expectedDigest, `${screenshot.file}: PNG не соответствует manifest`)
+
+      if (baseline.equals(screenshot.image))
+        continue
+
+      const actualPath = join(actualDir, screenshot.file)
+      writeFileSync(actualPath, screenshot.image)
+      failures.push(`${screenshot.file}: эталон ${baselinePath}, результат ${actualPath}`)
+    }
+
+    assert.deepEqual(failures, [], `Пиксельная регрессия:\n${failures.join('\n')}`)
+    rmSync(actualDir, { recursive: true, force: true })
+    console.log(`Пиксельная регрессия: ${slideCount}/${slideCount} слайдов совпали, Chromium ${environment.chromium}`)
+  }
+  catch (error) {
+    if (!UPDATE_BASELINES && existsSync(actualDir) && readdirSync(actualDir).length === 0)
+      rmSync(actualDir, { recursive: true, force: true })
+    throw error
+  }
+  finally {
+    await browser?.close()
+    await server?.close()
+  }
+}
+
+await run()

package/scripts/check-typography.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { parseArgs } from 'node:util'
+import { parseSync } from '@slidev/parser'
+import { createStaticDistServer } from './browser-smoke-runtime.mjs'
+import { inspectRenderedTypography } from './typography-browser.mjs'
+
+function loadChromium(deckPath) {
+  // В установленной теме Playwright может принадлежать проекту самой колоды.
+  const require = createRequire(import.meta.url)
+  try {
+    return require('playwright-chromium').chromium
+  }
+  catch {
+    try {
+      return createRequire(deckPath)('playwright-chromium').chromium
+    }
+    catch {
+      throw new Error('Для браузерной проверки установите в проект колоды playwright-chromium: npm install -D playwright-chromium')
+    }
+  }
+}
+
+export async function checkTypography({ deckPath, distDir }) {
+  const absolutePath = resolve(deckPath)
+  const slides = parseSync(readFileSync(absolutePath, 'utf8'), absolutePath).slides
+  const hashRouter = slides[0]?.frontmatter.routerMode === 'hash'
+  if (slides.some(slide => slide.frontmatter.src))
+    throw new Error('Браузерная проверка пока требует колоду без включений src. Соберите слайды в один Markdown-файл и повторите проверку его сборки.')
+  const chromium = loadChromium(absolutePath)
+  const issues = []
+  let browser
+  let server
+  let textCount = 0
+  try {
+    server = await createStaticDistServer(resolve(distDir))
+    browser = await chromium.launch({ args: ['--force-color-profile=srgb'] })
+    const context = await browser.newContext({
+      colorScheme: 'light',
+      reducedMotion: 'reduce',
+      serviceWorkers: 'block',
+      viewport: { width: 1280, height: 720 },
+    })
+    await context.grantPermissions(['screen-wake-lock'], { origin: server.origin })
+    const page = await context.newPage()
+    page.setDefaultTimeout(15_000)
+    let currentSlide = 1
+    page.on('pageerror', error => issues.push({ page: currentSlide, code: 'browser-error', message: error.message }))
+    for (let index = 0; index < slides.length; index += 1) {
+      const slideNumber = index + 1
+      currentSlide = slideNumber
+      try {
+        if (!hashRouter || index === 0)
+          await page.goto(`${server.origin}/${hashRouter ? '#/' : ''}${slideNumber}`, { waitUntil: 'domcontentloaded' })
+        else
+          await page.evaluate(number => window.location.hash = `#/${number}`, slideNumber)
+        const slide = page.locator(`.slidev-page[data-slidev-no="${slideNumber}"]`)
+        await slide.waitFor({ state: 'visible' })
+        if (!await slide.locator('.Slide').count())
+          throw new Error('В сборке не найден слайд темы Practicum. Проверьте соответствие файла колоды и каталога сборки.')
+        const result = await inspectRenderedTypography(slide)
+        textCount += result.textCount
+        issues.push(...result.issues.map(issue => ({ page: slideNumber, ...issue })))
+      }
+      catch (error) {
+        issues.push({ page: slideNumber, code: 'render-error', message: error.message })
+      }
+    }
+  }
+  finally {
+    await browser?.close()
+    await server?.close()
+  }
+  return { issues, slideCount: slides.length, textCount }
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      dist: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  })
+  if (values.help) {
+    console.log('Использование: slidev-practicum-check-typography [slides.md] [--dist dist]\n'
+      + 'Проверяет типографику показанных слайдов готовой сборки. Сначала соберите эту же колоду через slidev build.')
+    return
+  }
+  if (positionals.length > 1)
+    throw new Error('Укажите один файл колоды.')
+  const deckPath = resolve(positionals[0] ?? 'example.md')
+  const result = await checkTypography({ deckPath, distDir: values.dist ?? resolve(dirname(deckPath), 'dist') })
+  for (const issue of result.issues)
+    console.error(`Слайд ${issue.page}: ${issue.message}${issue.hint ? `\n  ${issue.hint}` : ''}`)
+  console.log(`Типографика: слайды=${result.slideCount}, текстовые фрагменты=${result.textCount}, нарушения=${result.issues.length}`)
+  process.exitCode = result.issues.length ? 1 : 0
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  main().catch((error) => {
+    console.error(error.message)
+    process.exitCode = 1
+  })
+}

package/scripts/test-typography.mjs

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { chromium } from 'playwright-chromium'
+import { checkTypography } from './check-typography.mjs'
+import { collectRenderedTypography, inspectRenderedTypography } from './typography-browser.mjs'
+
+const root = resolve(import.meta.dirname, '..')
+const deckPath = join(root, 'tests/fixtures/typography-deck.md')
+mkdirSync(join(root, '.slidev'), { recursive: true })
+const workRoot = mkdtempSync(join(root, '.slidev/typography-test-'))
+
+async function checkDom() {
+  const browser = await chromium.launch()
+  try {
+    const page = await browser.newPage()
+    await page.setContent(`
+      <style>
+        .Slot-Content { width: 600px; height: 400px; }
+        .Text { font-size: 24px; color: rgb(0, 0, 0); }
+      </style>
+      <div class="slidev-layout">
+        <div class="Header" style="font-size: 9px">Служебная шапка 2026</div>
+        <div class="Slot"><div class="Slot-Content">
+          <div class="Text">Первый <span style="color: #000">тот же цвет</span><span style="color: color(srgb 0 0 0)">цвет sRGB</span></div>
+          <div class="Text" style="font-size: 40px">Заголовок</div>
+          <data class="Text" style="font-size: 60px">42</data>
+          <div class="Logo" style="font-size: 1px">Логотип</div>
+          <svg><text style="font-size: 2px">Иллюстрация</text></svg>
+          <div style="opacity: 0"><span style="font-size: 3px">Скрытый текст</span></div>
+        </div></div>
+      </div>`)
+    const slide = page.locator('.slidev-layout')
+    assert.deepEqual((await inspectRenderedTypography(slide)).issues, [])
+    const visible = await slide.evaluate(collectRenderedTypography)
+    assert.deepEqual(visible.texts.map(text => text.text), ['Первый', 'тот же цвет', 'цвет sRGB', 'Заголовок', '42'])
+    assert.equal(new Set(visible.texts.map(text => text.color)).size, 1)
+
+    await page.locator('.Text span').last().evaluate((element) => {
+      element.style.color = 'color(srgb 1 0 0)'
+    })
+    assert.ok((await inspectRenderedTypography(slide)).issues.some(issue => issue.code === 'slot-colors'))
+
+    await page.locator('.Slot-Content').evaluate((content) => {
+      const timelineLabel = document.createElement('span')
+      timelineLabel.textContent = '2026'
+      timelineLabel.style.fontSize = '16px'
+      content.append(timelineLabel)
+    })
+    assert.ok((await inspectRenderedTypography(slide)).issues.some(issue => issue.code === 'text-sizes'))
+
+    await page.locator('.Text').first().evaluate((element) => {
+      element.setAttribute('data-text-color', 'text-muted')
+      element.style.transform = 'translateX(650px)'
+    })
+    const violations = (await inspectRenderedTypography(slide)).issues.map(issue => issue.code)
+    assert.ok(violations.includes('muted-text'))
+    assert.ok(violations.includes('text-overflow'))
+  }
+  finally {
+    await browser.close()
+  }
+}
+
+try {
+  const build = spawnSync(process.execPath, [
+    join(root, 'node_modules/@slidev/cli/bin/slidev.mjs'),
+    'build', deckPath, '--out', workRoot,
+  ], { cwd: root, encoding: 'utf8', timeout: 120_000, stdio: ['ignore', 'pipe', 'pipe'] })
+  assert.equal(build.status, 0, build.stderr || build.stdout)
+  const { issues, slideCount } = await checkTypography({ deckPath, distDir: workRoot })
+  assert.equal(slideCount, 9)
+  const codes = page => issues.filter(issue => issue.page === page).map(issue => issue.code)
+  for (const page of [1, 3, 8])
+    assert.deepEqual(codes(page), [], JSON.stringify(issues.filter(issue => issue.page === page)))
+  assert.ok(codes(2).includes('text-sizes'))
+  assert.ok(codes(4).includes('muted-text'))
+  assert.ok(codes(5).includes('text-overflow'))
+  assert.ok(codes(6).includes('number-sizes'))
+  assert.ok(codes(7).includes('slot-colors'))
+  assert.ok(codes(9).includes('text-overflow'), JSON.stringify(issues.filter(issue => issue.page === 9)))
+  assert.equal(issues.some(issue => ['render-error', 'browser-error'].includes(issue.code)), false, JSON.stringify(issues))
+  await checkDom()
+  console.log('Типографика: проверены 9 слайдов с явной разметкой и Markdown, цвета, исключения и геометрия DOM.')
+}
+finally {
+  rmSync(workRoot, { recursive: true, force: true })
+}