@polderlabs/bizar 10.7.2 → 10.11.0

package/bizar-dash/tests/eval/runner.test.mjs

@@ -1,471 +0,0 @@
-/**
- * tests/eval/runner.test.mjs
- *
- * v5.0.0 — Tests for the eval runner.
- *
- * Verifies:
- *   - runFixture returns correct shape
- *   - All check types work (contains, notContains, regex, jsonSchema, maxTokens, maxLatencyMs)
- *   - Latency tracking
- *   - Timeout enforcement
- *   - Suite parallelism
- */
-
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const EVAL = await import('../../src/server/eval.mjs');
-
-// ── Mock LLM call helpers ──────────────────────────────────────────────────────
-
-function mockLlmCall({ content = 'ok', latencyMs = 10, tokens = 100 } = {}) {
-  return async (prompt, opts) => {
-    await new Promise((r) => setTimeout(r, latencyMs));
-    return {
-      content,
-      usage: {
-        inputTokens: tokens,
-        outputTokens: tokens,
-        totalTokens: tokens * 2,
-      },
-    };
-  };
-}
-
-function failingLlmCall() {
-  return async (prompt, opts) => {
-    throw new Error('LLM error');
-  };
-}
-
-// ── Fixtures ───────────────────────────────────────────────────────────────────
-
-describe('eval runner', () => {
-
-  describe('runFixture', () => {
-
-    it('returns correct shape', async () => {
-      const fixture = {
-        id: 'test-fixture',
-        name: 'Test',
-        description: 'Test fixture',
-        agent: 'thor',
-        prompt: 'Say hello',
-        expected: {},
-      };
-
-      const result = await EVAL.runFixture(fixture, {
-        llmCall: mockLlmCall({ content: 'hello world' }),
-      });
-
-      assert.strictEqual(result.fixtureId, 'test-fixture');
-      assert.strictEqual(typeof result.ok, 'boolean');
-      assert.ok(Array.isArray(result.checks));
-      assert.ok(typeof result.latencyMs === 'number');
-      assert.strictEqual(result.content, 'hello world');
-      assert.ok(result.usage);
-      assert.strictEqual(result.usage.totalTokens, 200);
-    });
-
-    describe('contains check', () => {
-      it('passes when content includes expected substring', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { contains: ['hello', 'world'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello world' }),
-        });
-        assert.strictEqual(result.ok, true);
-        const containsCheck = result.checks.find((c) => c.kind === 'contains');
-        assert.ok(containsCheck);
-        assert.strictEqual(containsCheck.ok, true);
-      });
-
-      it('fails when content does not include expected substring', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { contains: ['goodbye'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello world' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const containsCheck = result.checks.find((c) => c.kind === 'contains');
-        assert.ok(containsCheck);
-        assert.strictEqual(containsCheck.ok, false);
-        assert.ok(containsCheck.message.includes('goodbye'));
-      });
-    });
-
-    describe('notContains check', () => {
-      it('passes when content does NOT include forbidden substring', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { notContains: ['error', 'fail'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello world' }),
-        });
-        assert.strictEqual(result.ok, true);
-        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
-        assert.ok(notContainsCheck);
-        assert.strictEqual(notContainsCheck.ok, true);
-      });
-
-      it('fails when content includes forbidden substring', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { notContains: ['error'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello error world' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
-        assert.ok(notContainsCheck);
-        assert.strictEqual(notContainsCheck.ok, false);
-      });
-    });
-
-    describe('regex check', () => {
-      it('passes when regex matches', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { regex: ['hello\\s+world'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello world' }),
-        });
-        assert.strictEqual(result.ok, true);
-        const regexCheck = result.checks.find((c) => c.kind === 'regex');
-        assert.ok(regexCheck);
-        assert.strictEqual(regexCheck.ok, true);
-      });
-
-      it('fails when regex does not match', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { regex: ['goodbye\\s+world'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello world' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const regexCheck = result.checks.find((c) => c.kind === 'regex');
-        assert.ok(regexCheck);
-        assert.strictEqual(regexCheck.ok, false);
-      });
-
-      it('fails gracefully on invalid regex', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { regex: ['[invalid'] },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'hello' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const regexCheck = result.checks.find((c) => c.kind === 'regex');
-        assert.ok(regexCheck);
-        assert.strictEqual(regexCheck.ok, false);
-        assert.ok(regexCheck.message.includes('invalid regex'));
-      });
-    });
-
-    describe('jsonSchema check', () => {
-      it('passes when response is valid JSON matching schema', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: {
-            jsonSchema: {
-              type: 'object',
-              required: ['status'],
-              properties: { status: { type: 'string' } },
-            },
-          },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
-        });
-        assert.strictEqual(result.ok, true);
-        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
-        assert.ok(schemaCheck);
-        assert.strictEqual(schemaCheck.ok, true);
-      });
-
-      it('fails when response is not valid JSON', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { jsonSchema: { type: 'object' } },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: 'not json' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
-        assert.ok(schemaCheck);
-        assert.strictEqual(schemaCheck.ok, false);
-      });
-
-      it('fails when required property is missing', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: {
-            jsonSchema: {
-              type: 'object',
-              required: ['version'],
-              properties: { version: { type: 'string' } },
-            },
-          },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
-        });
-        assert.strictEqual(result.ok, false);
-        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
-        assert.ok(schemaCheck);
-        assert.strictEqual(schemaCheck.ok, false);
-        assert.ok(schemaCheck.message.includes('missing required property'));
-      });
-    });
-
-    describe('maxTokens check', () => {
-      it('passes when token count is under limit', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { maxTokens: 1000 },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ tokens: 100 }),
-        });
-        assert.strictEqual(result.ok, true);
-        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
-        assert.ok(tokenCheck);
-        assert.strictEqual(tokenCheck.ok, true);
-      });
-
-      it('fails when token count exceeds limit', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { maxTokens: 50 },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ tokens: 100 }),
-        });
-        assert.strictEqual(result.ok, false);
-        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
-        assert.ok(tokenCheck);
-        assert.strictEqual(tokenCheck.ok, false);
-        assert.ok(tokenCheck.message.includes('exceeds max'));
-      });
-    });
-
-    describe('maxLatencyMs check', () => {
-      it('passes when latency is under limit', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { maxLatencyMs: 5000 },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ latencyMs: 10 }),
-        });
-        assert.strictEqual(result.ok, true);
-        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
-        assert.ok(latencyCheck);
-        assert.strictEqual(latencyCheck.ok, true);
-      });
-
-      it('fails when latency exceeds limit', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: { maxLatencyMs: 5 },
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: mockLlmCall({ latencyMs: 100 }),
-        });
-        assert.strictEqual(result.ok, false);
-        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
-        assert.ok(latencyCheck);
-        assert.strictEqual(latencyCheck.ok, false);
-        assert.ok(latencyCheck.message.includes('exceeds max'));
-      });
-    });
-
-    describe('timeout enforcement', () => {
-      it('returns timeout check on timeout', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: {},
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: async () => {
-            await new Promise((r) => setTimeout(r, 200));
-            return { content: 'ok', usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } };
-          },
-          timeoutMs: 50,
-        });
-        assert.strictEqual(result.ok, false);
-        const timeoutCheck = result.checks.find((c) => c.kind === 'timeout');
-        assert.ok(timeoutCheck);
-        assert.strictEqual(timeoutCheck.ok, false);
-      });
-    });
-
-    describe('error handling', () => {
-      it('returns error check when LLM call throws', async () => {
-        const fixture = {
-          id: 'test',
-          agent: 'thor',
-          prompt: 'test',
-          expected: {},
-        };
-        const result = await EVAL.runFixture(fixture, {
-          llmCall: failingLlmCall(),
-        });
-        assert.strictEqual(result.ok, false);
-        const errorCheck = result.checks.find((c) => c.kind === 'error');
-        assert.ok(errorCheck);
-        assert.strictEqual(errorCheck.ok, false);
-        assert.ok(errorCheck.message.includes('LLM error'));
-      });
-    });
-  });
-
-  describe('runSuite', () => {
-    const suiteDir = join(tmpdir(), `eval-suite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-
-    beforeEach(() => {
-      mkdirSync(suiteDir, { recursive: true });
-      writeFileSync(join(suiteDir, 'fix1.json'), JSON.stringify({
-        id: 'fix1',
-        name: 'Fix 1',
-        description: 'First fixture',
-        agent: 'thor',
-        prompt: 'Say hello',
-        expected: { contains: ['hello'] },
-      }));
-      writeFileSync(join(suiteDir, 'fix2.json'), JSON.stringify({
-        id: 'fix2',
-        name: 'Fix 2',
-        description: 'Second fixture',
-        agent: 'thor',
-        prompt: 'Say goodbye',
-        expected: { contains: ['goodbye'] },
-      }));
-    });
-
-    afterEach(() => {
-      rmSync(suiteDir, { recursive: true, force: true });
-    });
-
-    it('runs all fixtures in a directory', async () => {
-      const result = await EVAL.runSuite(suiteDir, {
-        llmCall: mockLlmCall({ content: 'hello and goodbye' }),
-        concurrency: 5,
-      });
-      assert.strictEqual(result.total, 2);
-      assert.strictEqual(result.passed, 2);
-      assert.strictEqual(result.failed, 0);
-      assert.strictEqual(result.results.length, 2);
-    });
-
-    it('reports failures correctly', async () => {
-      const result = await EVAL.runSuite(suiteDir, {
-        llmCall: mockLlmCall({ content: 'hello only' }),
-        concurrency: 5,
-      });
-      assert.strictEqual(result.total, 2);
-      assert.strictEqual(result.passed, 1);
-      assert.strictEqual(result.failed, 1);
-    });
-
-    it('runs fixtures in parallel batches', async () => {
-      const start = Date.now();
-      // Create 6 fixtures with unique IDs to test batching
-      for (let i = 0; i < 6; i++) {
-        writeFileSync(join(suiteDir, `batch${i}.json`), JSON.stringify({
-          id: `batch${i}`,
-          name: `Batch ${i}`,
-          description: 'Test fixture',
-          agent: 'thor',
-          prompt: 'Say hello',
-          expected: { contains: ['hello'] },
-        }));
-      }
-      const result = await EVAL.runSuite(suiteDir, {
-        llmCall: mockLlmCall({ latencyMs: 50 }),
-        concurrency: 3,
-      });
-      // 2 original (fix1, fix2) + 6 new (batch0-5) = 8
-      assert.ok(result.total >= 8, `Expected at least 8 fixtures, got ${result.total}`);
-      // Parallel batches should complete faster than sequential
-      const elapsed = Date.now() - start;
-      assert.ok(elapsed < 500, `Should complete quickly, took ${elapsed}ms`);
-    });
-
-    it('handles suite with no fixtures', async () => {
-      const emptyDir = join(tmpdir(), `eval-empty-${Date.now()}`);
-      mkdirSync(emptyDir, { recursive: true });
-      const result = await EVAL.runSuite(emptyDir, {
-        llmCall: mockLlmCall(),
-        concurrency: 5,
-      });
-      assert.strictEqual(result.total, 0);
-      assert.strictEqual(result.passed, 0);
-      assert.strictEqual(result.failed, 0);
-      rmSync(emptyDir, { recursive: true, force: true });
-    });
-
-    it('loads suite JSON with array of fixtures', async () => {
-      const suiteFile = join(suiteDir, 'suite.json');
-      writeFileSync(suiteFile, JSON.stringify({
-        id: 'my-suite',
-        fixtures: [
-          { id: 'f1', name: 'F1', description: 'F1', agent: 'thor', prompt: 'hi', expected: { contains: ['hi'] } },
-          { id: 'f2', name: 'F2', description: 'F2', agent: 'thor', prompt: 'bye', expected: { contains: ['bye'] } },
-        ],
-      }));
-      const result = await EVAL.runSuite(suiteDir, {
-        llmCall: mockLlmCall({ content: 'hi and bye' }),
-        concurrency: 5,
-      });
-      assert.strictEqual(result.total, 4); // 2 individual + 2 in suite
-    });
-  });
-});

package/bizar-dash/tests/eval-csv.test.mjs

@@ -1,67 +0,0 @@
-// tests/eval-csv.test.mjs — v5.3.0
-// Tests for CSV export functionality in eval.mjs
-
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { toCSV } from '../src/server/eval.mjs';
-
-describe('CSV export', () => {
-  it('produces valid CSV with headers', () => {
-    const csv = toCSV([
-      { fixtureId: 'test-1', name: 'Test', ok: true, latencyMs: 100, checks: [] },
-    ]);
-    assert.ok(csv.split('\n')[0].includes('fixture_id'));
-    assert.ok(csv.split('\n')[0].includes('name'));
-    assert.ok(csv.split('\n')[0].includes('ok'));
-    assert.ok(csv.split('\n')[0].includes('pass_count'));
-    assert.ok(csv.split('\n')[0].includes('fail_count'));
-    assert.ok(csv.split('\n')[0].includes('latency_ms'));
-    assert.ok(csv.split('\n')[0].includes('tokens'));
-    assert.ok(csv.split('\n')[0].includes('timestamp'));
-  });
-
-  it('escapes commas in values', () => {
-    const csv = toCSV([{ fixtureId: 'a,b', ok: true, checks: [] }]);
-    assert.ok(csv.includes('"a,b"'));
-  });
-
-  it('escapes quotes in values', () => {
-    const csv = toCSV([{ fixtureId: 'a"b', ok: true, checks: [] }]);
-    assert.ok(csv.includes('"a""b"'));
-  });
-
-  it('handles newlines in values', () => {
-    const csv = toCSV([{ fixtureId: 'a\nb', ok: true, checks: [] }]);
-    assert.ok(csv.includes('"a\nb"'));
-  });
-
-  it('outputs ok as 1 or 0', () => {
-    const csvPass = toCSV([{ fixtureId: 'p', ok: true, checks: [] }]);
-    const csvFail = toCSV([{ fixtureId: 'f', ok: false, checks: [] }]);
-    assert.ok(csvPass.match(/,1,/));
-    assert.ok(csvFail.match(/,0,/));
-  });
-
-  it('counts pass/fail checks correctly', () => {
-    const csv = toCSV([
-      {
-        fixtureId: 'c1',
-        ok: false,
-        checks: [
-          { pass: true },
-          { pass: false, message: 'failed check' },
-          { pass: true },
-        ],
-      },
-    ]);
-    // pass_count=2, fail_count=1
-    const row = csv.split('\n')[1];
-    assert.ok(row.match(/c1.*,2,1/));
-  });
-
-  it('returns empty string for missing optional fields', () => {
-    const csv = toCSV([{ fixtureId: 'minimal' }]);
-    // Should not throw and should have all 9 columns
-    assert.strictEqual(csv.split('\n')[0].split(',').length, 9);
-  });
-});

package/bizar-dash/tests/eval-scheduled.test.mjs

@@ -1,84 +0,0 @@
-// tests/eval-scheduled.test.mjs — v5.3.0
-// Tests for eval schedule CRUD
-
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { rmSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-describe('Eval schedule CRUD', () => {
-  const originalConfigDir = process.env.BIZAR_EVAL_CONFIG_DIR;
-
-  beforeEach(() => {
-    // Use a unique config dir per test to avoid cross-test pollution
-    const testId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    process.env.BIZAR_EVAL_CONFIG_DIR = `/tmp/bizar-eval-config-${testId}`;
-    mkdirSync(process.env.BIZAR_EVAL_CONFIG_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    process.env.BIZAR_EVAL_CONFIG_DIR = originalConfigDir;
-  });
-
-  it('registerEvalSchedule returns a schedule with id', async () => {
-    // Dynamic import ensures env var is set before module initializes
-    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
-    const { registerEvalSchedule } = mod;
-    const schedule = registerEvalSchedule({
-      name: 'Daily check',
-      suitePath: './fixtures',
-      cron: '0 8 * * *',
-      agent: 'thor',
-    });
-    assert.ok(schedule.id);
-    assert.strictEqual(schedule.name, 'Daily check');
-    assert.strictEqual(schedule.suitePath, './fixtures');
-    assert.strictEqual(schedule.cron, '0 8 * * *');
-    assert.strictEqual(schedule.agent, 'thor');
-  });
-
-  it('listEvalSchedules returns all registered schedules', async () => {
-    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}-${Math.random()}`);
-    const { registerEvalSchedule, listEvalSchedules } = mod;
-    registerEvalSchedule({ name: 's1', suitePath: './a', cron: '0 9 * * *' });
-    registerEvalSchedule({ name: 's2', suitePath: './b', cron: '0 10 * * *' });
-    const schedules = listEvalSchedules();
-    assert.strictEqual(schedules.length, 2);
-    assert.ok(schedules.find((s) => s.name === 's1'));
-    assert.ok(schedules.find((s) => s.name === 's2'));
-  });
-
-  it('deleteEvalSchedule removes a schedule by id', async () => {
-    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
-    const { registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } = mod;
-    const sched = registerEvalSchedule({ name: 'to-delete', suitePath: './x', cron: '0 9 * * *' });
-    const result = deleteEvalSchedule(sched.id);
-    assert.strictEqual(result.ok, true);
-    const remaining = listEvalSchedules();
-    assert.strictEqual(remaining.find((s) => s.id === sched.id), undefined);
-  });
-
-  it('deleteEvalSchedule returns ok:false for unknown id', async () => {
-    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
-    const { deleteEvalSchedule } = mod;
-    const result = deleteEvalSchedule('does-not-exist');
-    assert.strictEqual(result.ok, false);
-  });
-
-  it('schedule ids are unique across multiple registrations', async () => {
-    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
-    const { registerEvalSchedule, listEvalSchedules } = mod;
-    const ids = new Set();
-    for (let i = 0; i < 10; i++) {
-      ids.add(registerEvalSchedule({ name: `s${i}`, suitePath: '.', cron: '* * * * *' }).id);
-    }
-    assert.strictEqual(ids.size, 10);
-  });
-});
-
-describe('schedules runner eval-run action', () => {
-  it('schedulesRunner module loads and exposes tick', async () => {
-    const { schedulesRunner } = await import('../src/server/schedules-runner.mjs');
-    assert.strictEqual(typeof schedulesRunner.tick, 'function');
-  });
-});

package/bizar-dash/tests/focus-visible.test.mjs

@@ -1,30 +0,0 @@
-// Tests L4 — focus-visible CSS rule exists for custom buttons + sidebar items.
-
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-const cssPath = resolve(import.meta.dirname, '../src/web/v8/ui/styles/globals.css');
-const css = readFileSync(cssPath, 'utf8');
-
-test('globals.css defines a focus-visible ring for .v8-btn', () => {
-  assert.match(css, /\.v8-btn:focus-visible/);
-});
-
-test('globals.css defines a focus-visible ring for .v8-button', () => {
-  assert.match(css, /\.v8-button:focus-visible/);
-});
-
-test('globals.css defines a focus-visible ring for sidebar section toggle', () => {
-  assert.match(css, /button\[data-section-toggle\]:focus-visible/);
-});
-
-test('globals.css defines a focus-visible ring for sidebar nav item', () => {
-  assert.match(css, /button\[data-nav-item\]:focus-visible/);
-});
-
-test('focus rule uses outline + outline-offset (visible keyboard affordance)', () => {
-  assert.match(css, /outline:\s*2px solid var\(--accent\)/);
-  assert.match(css, /outline-offset:\s*2px/);
-});