@opensassi/opencode 0.1.0

package/scripts/install.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# opencode project environment installer — OS detection and dispatch
+# Usage: bash scripts/install.sh
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+OS="$(uname -s)"
+
+detect_macos_codename() {
+  local ver="$1"
+  if [[ $ver == 15.* ]]; then   echo "sequoia"
+  elif [[ $ver == 14.* ]]; then echo "sonoma"
+  elif [[ $ver == 13.* ]]; then echo "ventura"
+  elif [[ $ver == 12.* ]]; then echo "monterey"
+  elif [[ $ver == 11.* ]]; then echo "big-sur"
+  else                         echo "unknown"
+  fi
+}
+
+case "$OS" in
+  Darwin)
+    VERSION=$(sw_vers -productVersion)
+    CODENAME=$(detect_macos_codename "$VERSION")
+    DIR="macos-${CODENAME}-${VERSION}"
+    INSTALLER="$SCRIPT_DIR/install/osx/$DIR/install.sh"
+
+    if [ -f "$INSTALLER" ]; then
+      echo "==> opencode: detected macOS ${VERSION} (${CODENAME})"
+      bash "$INSTALLER"
+    else
+      echo "==> opencode: no installer for macOS ${VERSION} (${CODENAME})"
+      echo "   Expected: $INSTALLER"
+      echo "   Try running with a supported macOS version (11.0 or later)."
+      exit 1
+    fi
+    ;;
+
+  Linux)
+    # Check for WSL (Windows Subsystem for Linux)
+    if grep -qi "microsoft\|wsl" /proc/version 2>/dev/null; then
+      echo "==> opencode: WSL detected"
+      echo "   Run the Windows installer from PowerShell as Administrator:"
+      echo ""
+      echo "     powershell -ExecutionPolicy Bypass -File scripts\\install.ps1"
+      echo ""
+      echo "   If scripts/install.ps1 is not available, run the WSL2 installer directly:"
+      echo "     powershell -ExecutionPolicy Bypass -File scripts\\install\\windows\\wsl2\\install.ps1"
+      echo ""
+      exit 0
+    fi
+
+    # Read distro info
+    if [ ! -f /etc/os-release ]; then
+      echo "==> opencode: /etc/os-release not found — cannot detect Linux distro"
+      exit 1
+    fi
+
+    source /etc/os-release
+    NAME_LOWER=$(echo "${NAME%% *}" | tr '[:upper:]' '[:lower:]')
+    CODENAME="${VERSION_CODENAME:-$UBUNTU_CODENAME}"
+    VERSION="${VERSION_ID}"
+    DIR="${NAME_LOWER}-${CODENAME}-${VERSION}"
+    INSTALLER="$SCRIPT_DIR/install/linux/$DIR/install.sh"
+
+    if [ -f "$INSTALLER" ]; then
+      echo "==> opencode: detected ${NAME} ${VERSION} (${CODENAME})"
+      bash "$INSTALLER"
+    else
+      echo "==> opencode: no installer for ${NAME} ${VERSION} (${CODENAME})"
+      echo "   Expected: $INSTALLER"
+      echo "   Supported distributions are listed under scripts/install/linux/"
+      exit 1
+    fi
+    ;;
+
+  *)
+    echo "==> opencode: unsupported operating system: $OS"
+    echo "   Supported: macOS, Linux (Ubuntu, Debian, Fedora, etc.)"
+    echo "   Windows: use WSL2 + the PowerShell installer"
+    exit 1
+    ;;
+esac

package/scripts/puppeteer-config.json

@@ -0,0 +1,3 @@
+{
+  "args": ["--no-sandbox", "--disable-setuid-sandbox", "--disable-gpu"]
+}

package/scripts/test-artifacts.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { chromium } from 'playwright';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+function findArtifactDirs(specPath) {
+  // When --file is given, return only that spec's artifact directory
+  if (specPath) {
+    const absSpec = path.resolve(ROOT, specPath);
+    const specDir = path.dirname(absSpec);
+    const specName = path.basename(absSpec);
+    const artifactDir = path.join(specDir, '.artifacts', specName);
+    if (fs.existsSync(artifactDir)) {
+      const label = specPath.replace(/\.spec\.md$/, '');
+      return { [label]: artifactDir };
+    }
+    console.error(`  No artifact directory found for ${specPath} (expected ${artifactDir})`);
+    return {};
+  }
+
+  const dirs = {};
+
+  const rootArtifacts = path.join(ROOT, '.artifacts');
+  if (fs.existsSync(rootArtifacts)) dirs['.artifacts'] = rootArtifacts;
+
+  for (const base of ['src', 'source']) {
+    const baseDir = path.join(ROOT, base);
+    if (!fs.existsSync(baseDir)) continue;
+
+    const xFind = (dir, label) => {
+      const artifactPath = path.join(dir, '.artifacts');
+      if (fs.existsSync(artifactPath)) {
+        dirs[label] = artifactPath;
+      }
+      for (const sub of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (sub.isDirectory() && sub.name !== '.artifacts' && sub.name !== 'node_modules') {
+          xFind(path.join(dir, sub.name), `${label}/${sub.name}`);
+        }
+      }
+    };
+
+    for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        xFind(path.join(baseDir, entry.name), `${base}/${entry.name}`);
+      }
+    }
+  }
+
+  return dirs;
+}
+
+function findFilesRecursive(dir, ext) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findFilesRecursive(fullPath, ext));
+    } else if (entry.name.endsWith(ext)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+async function validateMermaid(specPath) {
+  const results = { pass: [], fail: [] };
+  const dirs = findArtifactDirs(specPath);
+
+  let totalFound = 0;
+  for (const [label, dir] of Object.entries(dirs)) {
+    const mmdFiles = findFilesRecursive(dir, '.mmd');
+    totalFound += mmdFiles.length;
+    for (const mmdFile of mmdFiles) {
+      const pngFile = mmdFile.replace(/\.mmd$/, '.png');
+      const rel = path.relative(ROOT, mmdFile);
+      try {
+        const puppeteerConfig = path.join(ROOT, 'scripts', 'puppeteer-config.json');
+        execSync(`mmdc -i "${mmdFile}" -o "${pngFile}" -b transparent -p "${puppeteerConfig}"`, { stdio: 'pipe', timeout: 30000 });
+        results.pass.push({ file: rel, png: path.relative(ROOT, pngFile) });
+        console.log(`  ✓ ${rel}`);
+      } catch (e) {
+        const stderr = (e.stderr || '').toString() || e.message;
+        results.fail.push({ file: rel, error: stderr.substring(0, 300) });
+        console.error(`  ✗ ${rel}: ${stderr.substring(0, 100)}`);
+      }
+    }
+  }
+
+  if (totalFound === 0) {
+    console.log('  (no .mmd files found — run `npm run extract` first)');
+  }
+
+  return results;
+}
+
+async function captureFilmstrip(htmlFile) {
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage({ viewport: { width: 720, height: 480 } });
+    await page.goto(`file://${htmlFile}`, { waitUntil: 'networkidle', timeout: 30000 });
+
+    const duration = await page.evaluate(() => {
+      if (typeof window.ANIMATION_DURATION_MS !== 'undefined') return window.ANIMATION_DURATION_MS;
+      try {
+        const meta = document.querySelector('meta[name="animation-duration-ms"]');
+        if (meta) return parseInt(meta.getAttribute('content'), 10);
+      } catch {}
+      return null;
+    });
+
+    const keyframes = await page.evaluate(() => {
+      if (typeof window.ANIMATION_KEYFRAMES !== 'undefined' && Array.isArray(window.ANIMATION_KEYFRAMES) && window.ANIMATION_KEYFRAMES.length > 0) {
+        return window.ANIMATION_KEYFRAMES.map(kf => ({ time: kf.time, label: kf.label }));
+      }
+      return null;
+    });
+
+    if (!keyframes) {
+      if (!duration || duration <= 0) {
+        return { pass: false, error: 'ANIMATION_KEYFRAMES not set in page' };
+      }
+    }
+
+    const filmDir = path.join(path.dirname(htmlFile), 'd3-animation-filmstrip');
+    fs.mkdirSync(filmDir, { recursive: true });
+
+    const frames = [];
+
+    if (keyframes) {
+      for (let i = 0; i < keyframes.length; i++) {
+        const kf = keyframes[i];
+        await page.evaluate((idx) => {
+          if (typeof window.jumpToKeyframe === 'function') {
+            window.jumpToKeyframe(idx);
+          } else {
+            // Fallback: seek via keyframes time if no jumpToKeyframe
+            const allKf = window.ANIMATION_KEYFRAMES || [];
+            const at = allKf[idx] ? allKf[idx].time : 0;
+            if (window.__seekToTime) window.__seekToTime(at);
+          }
+        }, i);
+        const settle = i === 0 ? 1000 : 200;
+        await new Promise(r => setTimeout(r, settle));
+        const domState = await page.evaluate(() => {
+          if (typeof window.getAnimationState === 'function') {
+            const s = window.getAnimationState();
+            return `hor=${s.hor} ver=${s.ver} prec=${s.precision} log=${s.logCount}`;
+          }
+          return '';
+        });
+        const frameFile = path.join(filmDir, `frame-${i}-${kf.label}.png`);
+        const tmpFile = path.join(filmDir, `frame-${i}-${kf.label}.tmp.png`);
+        await page.screenshot({ path: tmpFile });
+        const image = sharp(tmpFile);
+        const meta = await image.metadata();
+        if (meta.width !== 720) {
+          image.resize({ width: 720, fit: 'inside', withoutEnlargement: true });
+        }
+        await image.greyscale().toFile(frameFile);
+        fs.unlinkSync(tmpFile);
+        execSync(`convert "${frameFile}" -colorspace Gray "${frameFile}"`, { stdio: 'ignore' });
+        frames.push({ file: path.relative(ROOT, frameFile), label: kf.label, time: kf.time });
+        console.log(`    frame ${i}/${keyframes.length} → frame-${i}-${kf.label}.png  [${domState}]`);
+      }
+      return { pass: true, animationDurationMs: duration || keyframes[keyframes.length - 1].time, frames, keyframes, skipped: false };
+    }
+
+    // Fallback: fixed 5-fraction capture
+    for (let i = 0; i < 5; i++) {
+      const fraction = i / 4;
+      const waitMs = Math.round(fraction * duration);
+
+      if (i === 0) {
+        await new Promise(r => setTimeout(r, 500));
+      } else {
+        const prevFraction = (i - 1) / 4;
+        await new Promise(r => setTimeout(r, Math.round((fraction - prevFraction) * duration)));
+      }
+
+      const frameFile = path.join(filmDir, `frame-${i}.png`);
+      const tmpFile = path.join(filmDir, `frame-${i}.tmp.png`);
+      await page.screenshot({ path: tmpFile });
+      const image = sharp(tmpFile);
+      const meta = await image.metadata();
+      if (meta.width !== 720) {
+        image.resize({ width: 720, fit: 'inside', withoutEnlargement: true });
+      }
+      await image.greyscale().toFile(frameFile);
+      fs.unlinkSync(tmpFile);
+      execSync(`convert "${frameFile}" -colorspace Gray "${frameFile}"`, { stdio: 'ignore' });
+      frames.push({ file: path.relative(ROOT, frameFile), label: `frame-${i}`, time: waitMs });
+      console.log(`    frame ${i}/5 @ ${waitMs}ms → frame-${i}.png`);
+    }
+
+    return { pass: true, animationDurationMs: duration, frames, keyframes: null, skipped: false };
+  } finally {
+    await browser.close();
+  }
+}
+
+async function validateD3(specPath) {
+  const results = { pass: [], fail: [], skipped: [] };
+  const dirs = findArtifactDirs(specPath);
+
+  let totalFound = 0;
+  for (const [label, dir] of Object.entries(dirs)) {
+    const htmlFiles = findFilesRecursive(dir, '.html');
+    totalFound += htmlFiles.length;
+    for (const htmlFile of htmlFiles) {
+      const rel = path.relative(ROOT, htmlFile);
+      console.log(`  Loading ${rel}...`);
+      try {
+        const filmResult = await captureFilmstrip(htmlFile);
+        if (filmResult.pass) {
+          results.pass.push({ file: rel, ...filmResult });
+          console.log(`  ✓ ${rel} — ${filmResult.animationDurationMs}ms, ${filmResult.frames.length} frames`);
+        } else {
+          results.fail.push({ file: rel, error: filmResult.error });
+          console.error(`  ✗ ${rel}: ${filmResult.error}`);
+        }
+      } catch (e) {
+        results.fail.push({ file: rel, error: e.message });
+        console.error(`  ✗ ${rel}: ${e.message}`);
+      }
+    }
+  }
+
+  if (totalFound === 0) {
+    console.log('  (no HTML files found)');
+  }
+
+  return results;
+}
+
+function writeReports(mermaidResults, d3Results, specPath) {
+  const dirs = findArtifactDirs(specPath);
+  for (const [label, dir] of Object.entries(dirs)) {
+    const report = {
+      timestamp: new Date().toISOString(),
+      mermaid: [],
+      d3_filmstrip: []
+    };
+
+    const allResults = [
+      ...mermaidResults.pass.map(r => ({ ...r, pass: true })),
+      ...mermaidResults.fail.map(r => ({ ...r, pass: false })),
+    ];
+    for (const r of allResults) {
+      const absFile = path.join(ROOT, r.file);
+      if (absFile.startsWith(dir)) {
+        report.mermaid.push(r);
+      }
+    }
+
+    const allD3 = [
+      ...d3Results.pass.map(r => ({ ...r, pass: true, skipped: false })),
+      ...d3Results.fail.map(r => ({ ...r, pass: false, skipped: false })),
+      ...d3Results.skipped.map(r => ({ ...r, pass: true, skipped: true })),
+    ];
+    for (const r of allD3) {
+      const absFile = path.join(ROOT, r.file);
+      if (absFile.startsWith(dir)) {
+        report.d3_filmstrip.push(r);
+      }
+    }
+
+    fs.writeFileSync(path.join(dir, 'report.json'), JSON.stringify(report, null, 2));
+    console.log(`  report written to ${path.join(label, 'report.json')}`);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const fileIdx = args.indexOf('--file');
+  const specPath = fileIdx !== -1 ? args[fileIdx + 1] : null;
+
+  if (fileIdx !== -1 && !specPath) {
+    console.error('Usage: node scripts/test-artifacts.js [--file <relative-spec-path>]');
+    process.exit(1);
+  }
+  if (specPath) {
+    const absPath = path.resolve(ROOT, specPath);
+    if (!fs.existsSync(absPath)) {
+      console.error(`ERROR: Spec file not found: ${absPath}`);
+      process.exit(1);
+    }
+  }
+
+  console.log('=== Artifact Validation ===\n');
+
+  console.log('Searching for artifact directories...');
+  const dirs = findArtifactDirs(specPath);
+  if (Object.keys(dirs).length === 0) {
+    console.log('  No .artifacts/ directories found.');
+    console.log('  Run `npm run extract -- --all` first to extract artifacts from spec files.\n');
+    return;
+  }
+  for (const [label] of Object.entries(dirs)) {
+    console.log(`  found ${label}/`);
+  }
+
+  console.log('\n--- Mermaid Diagrams ---');
+  const mermaidResults = await validateMermaid(specPath);
+  const mMetrics = {
+    passed: mermaidResults.pass.length,
+    failed: mermaidResults.fail.length,
+    total: mermaidResults.pass.length + mermaidResults.fail.length,
+  };
+  console.log(`\n  ${mMetrics.passed} passed, ${mMetrics.failed} failed${mMetrics.total > 0 ? ` (${Math.round(mMetrics.passed / mMetrics.total * 100)}%)` : ''}\n`);
+
+  console.log('--- D3 Animation Filmstrip ---');
+  const d3Results = await validateD3(specPath);
+  const dMetrics = {
+    passed: d3Results.pass.length,
+    failed: d3Results.fail.length,
+    skipped: d3Results.skipped.length
+  };
+  console.log(`\n  ${dMetrics.passed} captured, ${dMetrics.failed} failed, ${dMetrics.skipped} skipped\n`);
+
+  console.log('--- Writing Reports ---');
+  writeReports(mermaidResults, d3Results, specPath);
+
+  const totalFail = mermaidResults.fail.length + d3Results.fail.length;
+  console.log(`\n=== Summary ===`);
+  console.log(`  Mermaid: ${mMetrics.passed}/${mMetrics.total} passed`);
+  console.log(`  D3 Filmstrip: ${dMetrics.passed} captured, ${dMetrics.failed} failed`);
+
+  if (totalFail > 0) {
+    console.error(`\n✗ ${totalFail} artifact(s) failed validation.`);
+    process.exit(1);
+  }
+
+  console.log('\n✓ All artifact validations passed.');
+}
+
+main().catch(e => {
+  console.error('Fatal error:', e);
+  process.exit(1);
+});

package/scripts/validate-all.js

@@ -0,0 +1,18 @@
+import { spawnSync } from 'node:child_process'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const dir = resolve(fileURLToPath(import.meta.url), '..')
+
+function run(script, args) {
+  const result = spawnSync(process.execPath, [resolve(dir, script), ...args], {
+    stdio: 'inherit'
+  })
+  return result.status ?? 1
+}
+
+const extractOk = run('extract-artifacts.js', ['--all'])
+if (extractOk !== 0) process.exit(extractOk)
+
+const testOk = run('test-artifacts.js', [])
+process.exit(testOk ?? 0)

package/scripts/verify-artifact.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import http from 'http';
+import { chromium } from 'playwright';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+function serveStatic(dir) {
+  const server = http.createServer((req, res) => {
+    const filePath = path.join(dir, req.url === '/' ? 'index.html' : req.url);
+    if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+      res.writeHead(404);
+      res.end('Not found');
+      return;
+    }
+    const ext = path.extname(filePath);
+    const mime = { '.html': 'text/html', '.js': 'application/javascript', '.css': 'text/css', '.png': 'image/png', '.svg': 'image/svg+xml' };
+    res.writeHead(200, { 'Content-Type': mime[ext] || 'application/octet-stream' });
+    fs.createReadStream(filePath).pipe(res);
+  });
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve(server));
+  });
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const fileIdx = args.indexOf('--file');
+  if (fileIdx === -1) {
+    console.error('Usage: node scripts/verify-artifact.js --file <path-to-d3-animation.html>');
+    process.exit(1);
+  }
+  return { filePath: args[fileIdx + 1] };
+}
+
+async function verify() {
+  const { filePath } = parseArgs();
+  const absPath = path.resolve(ROOT, filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(`ERROR: File not found: ${absPath}`);
+    process.exit(1);
+  }
+
+  const dir = path.dirname(absPath);
+  const fileName = path.basename(absPath);
+  const rel = path.relative(ROOT, absPath);
+
+  console.log(`Verifying ${rel}...\n`);
+
+  const server = await serveStatic(dir);
+  const port = server.address().port;
+  const url = `http://127.0.0.1:${port}/${fileName}`;
+
+  let browser;
+  const results = { pass: 0, fail: 0, total: 0, details: [] };
+
+  try {
+    browser = await chromium.launch({ headless: true });
+    const page = await browser.newPage({ viewport: { width: 720, height: 480 } });
+
+    await page.goto(url, { waitUntil: 'networkidle', timeout: 15000 });
+
+    // Check required globals
+    const duration = await page.evaluate(() => window.ANIMATION_DURATION_MS);
+    const keyframes = await page.evaluate(() => window.ANIMATION_KEYFRAMES);
+    const verification = await page.evaluate(() => window.ANIMATION_VERIFICATION);
+    const hasPlayPause = await page.evaluate(() => !!document.querySelector('[data-testid="play-pause"]'));
+
+    if (!duration || duration <= 0) {
+      console.error('  ✗ ANIMATION_DURATION_MS not set or invalid');
+      process.exit(1);
+    }
+    if (!keyframes || !keyframes.length) {
+      console.error('  ✗ ANIMATION_KEYFRAMES not set or empty');
+      process.exit(1);
+    }
+    if (!verification || verification.length !== keyframes.length) {
+      console.error('  ✗ ANIMATION_VERIFICATION missing or length mismatch');
+      process.exit(1);
+    }
+    if (!hasPlayPause) {
+      console.error('  ✗ [data-testid="play-pause"] not found');
+      process.exit(1);
+    }
+    console.log(`  ✓ Globals: duration=${duration}ms, keyframes=${keyframes.length}, [data-testid="play-pause"] found\n`);
+
+    // Verify each keyframe
+    for (let i = 0; i < verification.length; i++) {
+      const expected = verification[i];
+
+      await page.evaluate((idx) => window.jumpToKeyframe(idx), i);
+
+      const state = await page.evaluate(() => window.getAnimationState());
+
+      const assertions = [
+        { field: 'hor',         actual: state.hor,              expected: expected.hor },
+        { field: 'ver',         actual: state.ver,              expected: expected.ver },
+        { field: 'precision',   actual: state.precision,        expected: expected.precision },
+        { field: 'logCount',    actual: state.logCount,         expected: expected.logCount },
+      ];
+
+      if (expected.bounds) {
+        assertions.push({ field: 'boundsOpacity', actual: state.boundsOpacity, expected: '1' });
+      }
+
+      const failures = assertions.filter(a => String(a.actual) !== String(a.expected));
+      const passed = failures.length === 0;
+
+      if (passed) {
+        results.pass++;
+        console.log(`  ✓ [${i}] ${expected.label.padEnd(20)} hor=${state.hor} ver=${state.ver} prec=${state.precision} log=${state.logCount}`);
+      } else {
+        results.fail++;
+        console.error(`  ✗ [${i}] ${expected.label}:`);
+        for (const f of failures) {
+          console.error(`       ${f.field}: expected ${f.expected}, got ${f.actual}`);
+        }
+      }
+      results.total++;
+      results.details.push({ keyframe: i, label: expected.label, passed, failures: failures.map(f => f.field) });
+    }
+
+    // Check play/pause toggle
+    await page.evaluate(() => window.resetAnimation());
+    const playBtnTextBefore = await page.evaluate(() => document.querySelector('[data-testid="play-pause"]').textContent);
+    await page.click('[data-testid="play-pause"]');
+    await new Promise(r => setTimeout(r, 200));
+    const playBtnTextAfter = await page.evaluate(() => document.querySelector('[data-testid="play-pause"]').textContent);
+    const toggleOk = playBtnTextBefore !== playBtnTextAfter;
+    if (toggleOk) {
+      console.log(`  ✓ Play/Pause toggle works: "${playBtnTextBefore.trim()}" → "${playBtnTextAfter.trim()}"`);
+    } else {
+      console.error(`  ✗ Play/Pause toggle failed: text did not change ("${playBtnTextBefore.trim()}")`);
+    }
+
+    console.log(`\n=== Results ===`);
+    console.log(`  ${results.pass}/${results.total} keyframes passed`);
+    if (results.fail > 0) {
+      console.error(`  ${results.fail} keyframe(s) FAILED`);
+      process.exit(1);
+    }
+    console.log(`  Play/Pause toggle: ${toggleOk ? '✓' : '✗'}`);
+    console.log(`\n✓ All assertions passed.`);
+
+  } catch (e) {
+    console.error('Fatal error:', e.message);
+    process.exit(1);
+  } finally {
+    if (browser) await browser.close();
+    server.close();
+  }
+}
+
+verify();