Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
Select browser specs for targeted PRs from an Inertia coverage map (PRD-9548) (#6725)
Andrew Mikofalvy5b3098b91976
diff --git a/packages/app/src/build/e2e-coverage-contract.test.ts b/packages/app/src/build/e2e-coverage-contract.test.tsnew file mode 100644index 000000000..8b1954872--- /dev/null+++ b/packages/app/src/build/e2e-coverage-contract.test.ts@@ -0,0 +1,147 @@+import { describe, expect, test } from 'vitest';+import {+ browserScriptFile,+ e2eCoverageDir,+ executedOffsets,+ recordableSource,+ regionAt,+ type ScriptCoverage,+ serverScriptFiles,+ sourceRegions,+} from './e2e-coverage-contract';++const OK_ROOT = '/work/My Repo/public/open-knowledge';+const APP_DIR = `${OK_ROOT}/packages/app`;++const script = (url: string, functions: Array<[string, number, number]>): ScriptCoverage => ({+ url,+ functions: functions.map(([functionName, startOffset, count]) => ({+ functionName,+ ranges: [{ startOffset, endOffset: startOffset + 10, count }],+ })),+});++describe('which functions count as executed', () => {+ test('a function that ran counts, the module body and a function that never ran do not', () => {+ expect(+ executedOffsets(+ script('u', [+ ['', 0, 1],+ ['render', 40, 3],+ ['unused', 90, 0],+ ['', 120, 2],+ ]),+ ),+ ).toEqual([40, 120]);+ expect(executedOffsets(script('u', [['', 0, 1]]))).toEqual([]);+ });+});++describe('the coverage directory switch', () => {+ test('only a non-empty directory turns recording on', () => {+ expect(e2eCoverageDir({})).toBeUndefined();+ expect(e2eCoverageDir({ OK_E2E_COVERAGE_DIR: '' })).toBeUndefined();+ expect(e2eCoverageDir({ OK_E2E_COVERAGE_DIR: '/tmp/cov' })).toBe('/tmp/cov');+ });+});++describe('which files are recorded', () => {+ test('source files under the root are recorded by their root-relative path', () => {+ expect(recordableSource(`${APP_DIR}/src/editor/Tiptap.tsx`, OK_ROOT)).toBe(+ 'packages/app/src/editor/Tiptap.tsx',+ );+ expect(recordableSource(`${OK_ROOT}/packages/server/src/api-extension.ts`, OK_ROOT)).toBe(+ 'packages/server/src/api-extension.ts',+ );+ });++ test('dependencies, build output, test helpers, tests and paths outside the root are not', () => {+ for (const path of [+ `${OK_ROOT}/node_modules/.pnpm/react/index.js`,+ `${APP_DIR}/node_modules/.vite/deps/react.js`,+ `${OK_ROOT}/packages/server/dist/index.mjs`,+ `${APP_DIR}/tests/stress/_helpers/fixtures.ts`,+ `${APP_DIR}/src/build/app-version.test.ts`,+ `${OK_ROOT}/test-support/vitest.base.ts`,+ '/tmp/ok-vite-cache/deps/yjs.js',+ OK_ROOT,+ ])+ expect(recordableSource(path, OK_ROOT), path).toBeUndefined();+ });+});++describe('mapping a browser script URL to a file', () => {+ test('a Vite source URL resolves against the app root, and its query is dropped', () => {+ expect(browserScriptFile('http://127.0.0.1:4100/src/main.tsx?t=171', APP_DIR)).toBe(+ `${APP_DIR}/src/main.tsx`,+ );+ });++ test('an /@fs/ URL is the absolute file, with its encoded spaces decoded', () => {+ expect(+ browserScriptFile(+ 'http://127.0.0.1:4100/@fs/work/My%20Repo/public/open-knowledge/packages/core/src/index.ts?v=1',+ APP_DIR,+ ),+ ).toBe(`${OK_ROOT}/packages/core/src/index.ts`);+ });++ test('Vite internals, optimized dependencies, the page itself and non-HTTP scripts map to nothing', () => {+ for (const url of [+ 'http://127.0.0.1:4100/@vite/client',+ 'http://127.0.0.1:4100/@react-refresh',+ 'http://127.0.0.1:4100/@id/__x00__virtual',+ 'http://127.0.0.1:4100/node_modules/.vite/deps/react.js?v=1',+ 'http://127.0.0.1:4100/',+ 'chrome-extension://abc/script.js',+ 'not a url',+ 'http://127.0.0.1:4100/%E0%A4%A',+ ])+ expect(browserScriptFile(url, APP_DIR), url).toBeUndefined();+ });+});++describe('mapping a bundled server script back to its sources', () => {+ const bundle = [+ 'import { x } from "y";',+ '//#region src/a.ts',+ 'function a() { return 1; }',+ '//#endregion',+ '//#region src/http/b.ts',+ 'function b() { return 2; }',+ '//#endregion',+ 'export { a, b };',+ ].join('\n');+ const regions = sourceRegions(bundle);+ const offsetOf = (text: string) => bundle.indexOf(text);++ test('each region spans its marked source, in order', () => {+ expect(regions.map((region) => region.path)).toEqual(['src/a.ts', 'src/http/b.ts']);+ expect(regionAt(regions, offsetOf('function a'))?.path).toBe('src/a.ts');+ expect(regionAt(regions, offsetOf('function b'))?.path).toBe('src/http/b.ts');+ expect(regionAt(regions, offsetOf('import'))).toBeUndefined();+ expect(regionAt(regions, offsetOf('export'))).toBeUndefined();+ });++ test('an executed function is attributed to its region, and an unmarked script to itself', () => {+ const covered = script('file:///pkg/dist/index.mjs', [+ ['', 0, 1],+ ['b', offsetOf('function b'), 1],+ ['a', offsetOf('function a'), 0],+ ]);+ expect(serverScriptFiles(covered, '/pkg/dist/index.mjs', regions, '/pkg')).toEqual([+ '/pkg/src/http/b.ts',+ ]);+ expect(serverScriptFiles(covered, '/pkg/src/plain.mjs', [], '/pkg')).toEqual([+ '/pkg/src/plain.mjs',+ ]);+ expect(+ serverScriptFiles(script('file:///x', [['', 0, 1]]), '/pkg/dist/index.mjs', regions, '/pkg'),+ ).toEqual([]);+ });++ test('an unterminated region runs to the end of the script', () => {+ const open = sourceRegions('//#region src/tail.ts\nfunction t() {}\n');+ expect(open).toEqual([{ start: 0, end: 38, path: 'src/tail.ts' }]);+ });+});diff --git a/packages/app/src/build/e2e-coverage-contract.ts b/packages/app/src/build/e2e-coverage-contract.tsnew file mode 100644index 000000000..2c3867d86--- /dev/null+++ b/packages/app/src/build/e2e-coverage-contract.ts@@ -0,0 +1,135 @@+import { isAbsolute, join, relative, sep } from 'node:path';++const E2E_COVERAGE_DIR_ENV = 'OK_E2E_COVERAGE_DIR';+export const E2E_COVERAGE_PATH = '/__ok-e2e-coverage';++interface CoverageRange {+ readonly startOffset: number;+ readonly endOffset: number;+ readonly count: number;+}++interface FunctionCoverage {+ readonly functionName: string;+ readonly ranges: readonly CoverageRange[];+}++export interface ScriptCoverage {+ readonly url: string;+ readonly functions: readonly FunctionCoverage[];+}++export interface SourceRegion {+ readonly start: number;+ readonly end: number;+ readonly path: string;+}++type Env = Readonly<Record<string, string | undefined>>;++export function e2eCoverageDir(env: Env): string | undefined {+ const dir = env[E2E_COVERAGE_DIR_ENV];+ return dir === undefined || dir === '' ? undefined : dir;+}++function isModuleBody(fn: FunctionCoverage): boolean {+ return fn.functionName === '' && fn.ranges[0]?.startOffset === 0;+}++export function executedOffsets(script: ScriptCoverage): number[] {+ const offsets: number[] = [];+ for (const fn of script.functions) {+ const whole = fn.ranges[0];+ if (whole === undefined || whole.count <= 0 || isModuleBody(fn)) continue;+ offsets.push(whole.startOffset);+ }+ return offsets;+}++const UNRECORDED_SEGMENTS = new Set(['node_modules', 'dist', '.vite', '.vite-temp']);+const UNRECORDED_PREFIXES = ['packages/app/tests/', 'test-support/'];+const TEST_MODULE = /\.(test|test-helper|e2e|dom\.test|browser\.test)\.[cm]?[jt]sx?$/;++export function recordableSource(absPath: string, okRoot: string): string | undefined {+ const within = relative(okRoot, absPath).split(sep).join('/');+ if (within === '' || within.startsWith('..') || isAbsolute(within)) return undefined;+ if (within.split('/').some((segment) => UNRECORDED_SEGMENTS.has(segment))) return undefined;+ if (UNRECORDED_PREFIXES.some((prefix) => within.startsWith(prefix))) return undefined;+ if (TEST_MODULE.test(within)) return undefined;+ return within;+}++export function browserScriptFile(url: string, appDir: string): string | undefined {+ let parsed: URL;+ try {+ parsed = new URL(url);+ } catch {+ return undefined;+ }+ if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return undefined;+ let path: string;+ try {+ path = decodeURIComponent(parsed.pathname);+ } catch {+ return undefined;+ }+ if (path.startsWith('/@fs/')) return path.slice('/@fs'.length);+ if (path.startsWith('/@') || path.startsWith('/node_modules/') || path === '/') return undefined;+ return join(appDir, path);+}++const REGION_OPEN = /^\/\/#region (.+)$/;+const REGION_CLOSE = /^\/\/#endregion\b/;++export function sourceRegions(text: string): SourceRegion[] {+ const regions: SourceRegion[] = [];+ let open: { start: number; path: string } | undefined;+ let offset = 0;+ for (const line of text.split('\n')) {+ const opening = REGION_OPEN.exec(line);+ if (opening !== null) {+ if (open !== undefined) regions.push({ ...open, end: offset });+ open = { start: offset, path: opening[1]?.trim() ?? '' };+ } else if (REGION_CLOSE.test(line) && open !== undefined) {+ regions.push({ ...open, end: offset + line.length });+ open = undefined;+ }+ offset += line.length + 1;+ }+ if (open !== undefined) regions.push({ ...open, end: text.length });+ return regions;+}++export function regionAt(+ regions: readonly SourceRegion[],+ offset: number,+): SourceRegion | undefined {+ let low = 0;+ let high = regions.length - 1;+ while (low <= high) {+ const mid = (low + high) >> 1;+ const region = regions[mid];+ if (region === undefined) return undefined;+ if (offset < region.start) high = mid - 1;+ else if (offset >= region.end) low = mid + 1;+ else return region;+ }+ return undefined;+}++export function serverScriptFiles(+ script: ScriptCoverage,+ scriptFile: string,+ regions: readonly SourceRegion[],+ packageDir: string,+): string[] {+ const offsets = executedOffsets(script);+ if (offsets.length === 0) return [];+ if (regions.length === 0) return [scriptFile];+ const files = new Set<string>();+ for (const offset of offsets) {+ const region = regionAt(regions, offset);+ if (region !== undefined && region.path !== '') files.add(join(packageDir, region.path));+ }+ return [...files];+}diff --git a/packages/app/src/build/e2e-coverage-plugin.test.ts b/packages/app/src/build/e2e-coverage-plugin.test.tsnew file mode 100644index 000000000..bb522e816--- /dev/null+++ b/packages/app/src/build/e2e-coverage-plugin.test.ts@@ -0,0 +1,163 @@+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';+import type { ServerResponse } from 'node:http';+import { tmpdir } from 'node:os';+import { join } from 'node:path';+import { pathToFileURL } from 'node:url';+import type { Connect } from 'vite';+import { afterEach, describe, expect, test } from 'vitest';+import { E2E_COVERAGE_PATH, type ScriptCoverage } from './e2e-coverage-contract';+import {+ type CoverageSession,+ coverageMiddleware,+ diskScriptSources,+ inspectorCoverage,+ processCoverageFiles,+} from './e2e-coverage-plugin';++const dirs: string[] = [];+afterEach(() => {+ for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });+});++function fakeRoot(): { okRoot: string; bundle: string; text: string } {+ const okRoot = realpathSync(mkdtempSync(join(tmpdir(), 'ok-e2e-coverage-plugin-')));+ dirs.push(okRoot);+ const pkg = join(okRoot, 'packages', 'server');+ mkdirSync(join(pkg, 'dist'), { recursive: true });+ writeFileSync(join(pkg, 'package.json'), '{"name":"fake-server","type":"module"}');+ const text = [+ '//#region src/a.ts',+ 'export function a() { return 1; }',+ '//#endregion',+ '//#region src/b.ts',+ 'export function b() { return 2; }',+ '//#endregion',+ '',+ ].join('\n');+ const bundle = join(pkg, 'dist', 'index.mjs');+ writeFileSync(bundle, text);+ return { okRoot, bundle, text };+}++function call(+ middleware: Connect.NextHandleFunction,+ method: string,+ url: string,+): Promise<{ status: number; body: unknown; passed: boolean }> {+ return new Promise((resolve) => {+ let status = 0;+ const response = {+ set statusCode(code: number) {+ status = code;+ },+ setHeader: () => response,+ end: (text: string) => resolve({ status, body: JSON.parse(text), passed: false }),+ } as unknown as ServerResponse;+ middleware({ method, url } as Connect.IncomingMessage, response, () =>+ resolve({ status, body: null, passed: true }),+ );+ });+}++describe('server coverage over a bundled dist script', () => {+ test('an executed function maps through its region to the source file, and dependencies are skipped', () => {+ const { okRoot, bundle, text } = fakeRoot();+ const scripts: ScriptCoverage[] = [+ {+ url: pathToFileURL(bundle).href,+ functions: [+ { functionName: '', ranges: [{ startOffset: 0, endOffset: text.length, count: 1 }] },+ {+ functionName: 'b',+ ranges: [{ startOffset: text.indexOf('export function b'), endOffset: 0, count: 2 }],+ },+ ],+ },+ {+ url: pathToFileURL(join(okRoot, 'node_modules', 'dep', 'index.js')).href,+ functions: [{ functionName: 'x', ranges: [{ startOffset: 5, endOffset: 9, count: 1 }] }],+ },+ { url: 'node:internal/fs', functions: [] },+ ];+ expect(processCoverageFiles(scripts, okRoot, diskScriptSources())).toEqual([+ 'packages/server/src/b.ts',+ ]);+ });++ test('the in-process inspector reports a function a real module ran', async () => {+ const { okRoot, bundle } = fakeRoot();+ const session = inspectorCoverage();+ await session.takePreciseCoverage();+ const loaded = (await import(pathToFileURL(bundle).href)) as { a: () => number };+ expect(loaded.a()).toBe(1);+ expect(+ processCoverageFiles(await session.takePreciseCoverage(), okRoot, diskScriptSources()),+ ).toEqual(['packages/server/src/a.ts']);+ expect(+ processCoverageFiles(await session.takePreciseCoverage(), okRoot, diskScriptSources()),+ ).toEqual([]);+ });+});++describe('the coverage endpoint', () => {+ const session = (scripts: ScriptCoverage[]): CoverageSession & { calls: number } => {+ const fake = {+ calls: 0,+ async takePreciseCoverage() {+ fake.calls += 1;+ return scripts;+ },+ };+ return fake;+ };++ test('reset clears the counters and reports nothing; take reports what ran since', async () => {+ const { okRoot, bundle, text } = fakeRoot();+ const ran = session([+ {+ url: pathToFileURL(bundle).href,+ functions: [+ {+ functionName: 'a',+ ranges: [{ startOffset: text.indexOf('export function a'), endOffset: 0, count: 1 }],+ },+ ],+ },+ ]);+ const middleware = coverageMiddleware(okRoot, ran, diskScriptSources());+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=reset`)).toEqual({+ status: 200,+ body: { files: [] },+ passed: false,+ });+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=take`)).toEqual({+ status: 200,+ body: { files: ['packages/server/src/a.ts'] },+ passed: false,+ });+ expect(ran.calls).toBe(2);+ });++ test('other paths and methods pass through, and an unknown op is refused', async () => {+ const quiet = session([]);+ const middleware = coverageMiddleware('/nowhere', quiet, diskScriptSources());+ expect((await call(middleware, 'GET', `${E2E_COVERAGE_PATH}?op=take`)).passed).toBe(true);+ expect((await call(middleware, 'POST', '/api/config')).passed).toBe(true);+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=dump`)).toMatchObject({+ status: 400,+ });+ expect(quiet.calls).toBe(0);+ });++ test('a session that fails answers 500 rather than hanging the test', async () => {+ const failing: CoverageSession = {+ takePreciseCoverage: () => Promise.reject(new Error('inspector closed')),+ };+ const middleware = coverageMiddleware('/nowhere', failing, diskScriptSources());+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=take`)).toEqual({+ status: 500,+ body: { error: 'inspector closed' },+ passed: false,+ });+ });+});diff --git a/packages/app/src/build/e2e-coverage-plugin.ts b/packages/app/src/build/e2e-coverage-plugin.tsnew file mode 100644index 000000000..803ad52ab--- /dev/null+++ b/packages/app/src/build/e2e-coverage-plugin.ts@@ -0,0 +1,137 @@+import { existsSync, readFileSync } from 'node:fs';+import type { ServerResponse } from 'node:http';+import { Session } from 'node:inspector/promises';+import { dirname, join } from 'node:path';+import { fileURLToPath } from 'node:url';+import type { Connect, Plugin } from 'vite';+import {+ E2E_COVERAGE_PATH,+ recordableSource,+ type ScriptCoverage,+ type SourceRegion,+ serverScriptFiles,+ sourceRegions,+} from './e2e-coverage-contract';++interface ScriptSource {+ readonly file: string;+ readonly packageDir: string;+ readonly regions: readonly SourceRegion[];+}++export interface CoverageSession {+ takePreciseCoverage(): Promise<readonly ScriptCoverage[]>;+}++function packageDirOf(file: string): string | undefined {+ let dir = dirname(file);+ while (dir !== dirname(dir)) {+ if (existsSync(join(dir, 'package.json'))) return dir;+ dir = dirname(dir);+ }+ return undefined;+}++export function processCoverageFiles(+ scripts: readonly ScriptCoverage[],+ okRoot: string,+ sourceOf: (url: string) => ScriptSource | undefined,+): string[] {+ const files = new Set<string>();+ for (const script of scripts) {+ if (!script.url.startsWith('file://') || script.url.includes('/node_modules/')) continue;+ const source = sourceOf(script.url);+ if (source === undefined) continue;+ for (const file of serverScriptFiles(script, source.file, source.regions, source.packageDir)) {+ const recorded = recordableSource(file, okRoot);+ if (recorded !== undefined) files.add(recorded);+ }+ }+ return [...files].sort();+}++export function diskScriptSources(): (url: string) => ScriptSource | undefined {+ const cache = new Map<string, ScriptSource | undefined>();+ return (url) => {+ if (cache.has(url)) return cache.get(url);+ let source: ScriptSource | undefined;+ try {+ const file = fileURLToPath(url);+ const packageDir = packageDirOf(file);+ if (packageDir !== undefined) {+ source = { file, packageDir, regions: sourceRegions(readFileSync(file, 'utf8')) };+ }+ } catch {+ source = undefined;+ }+ cache.set(url, source);+ return source;+ };+}++export function inspectorCoverage(): CoverageSession {+ let started: Promise<Session> | undefined;+ const start = async (): Promise<Session> => {+ const session = new Session();+ session.connect();+ await session.post('Profiler.enable');+ await session.post('Profiler.startPreciseCoverage', { callCount: false, detailed: false });+ return session;+ };+ return {+ async takePreciseCoverage() {+ started ??= start();+ const session = await started;+ const { result } = await session.post('Profiler.takePreciseCoverage');+ return result;+ },+ };+}++export function coverageMiddleware(+ okRoot: string,+ session: CoverageSession,+ sourceOf: (url: string) => ScriptSource | undefined,+): Connect.NextHandleFunction {+ return (request: Connect.IncomingMessage, response: ServerResponse, next) => {+ const url = new URL(request.url ?? '/', 'http://localhost');+ if (request.method !== 'POST' || url.pathname !== E2E_COVERAGE_PATH) {+ next();+ return;+ }+ const op = url.searchParams.get('op');+ if (op !== 'reset' && op !== 'take') {+ response.statusCode = 400;+ response.end(JSON.stringify({ error: `op must be reset or take, not ${op}` }));+ return;+ }+ session.takePreciseCoverage().then(+ (scripts) => {+ response.statusCode = 200;+ response.setHeader('content-type', 'application/json');+ response.setHeader('cache-control', 'no-store');+ response.end(+ JSON.stringify({+ files: op === 'take' ? processCoverageFiles(scripts, okRoot, sourceOf) : [],+ }),+ );+ },+ (error: unknown) => {+ response.statusCode = 500;+ response.end(+ JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),+ );+ },+ );+ };+}++export function e2eCoveragePlugin(okRoot: string): Plugin {+ const middleware = coverageMiddleware(okRoot, inspectorCoverage(), diskScriptSources());+ return {+ name: 'ok-e2e-coverage',+ configureServer(server) {+ server.middlewares.use(middleware);+ },+ };+}diff --git a/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.ts b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.tsnew file mode 100644index 000000000..4a74c2a57--- /dev/null+++ b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.ts@@ -0,0 +1,61 @@+import { describe, expect, test } from 'vitest';+import {+ browserCoverageFiles,+ COVERAGE_RECORD_SCHEMA,+ coverageRecordLine,+ specPath,+} from './e2e-coverage.ts';++const OK_ROOT = '/work/My Repo/public/open-knowledge';+const APP_DIR = `${OK_ROOT}/packages/app`;+const ran = (url: string, count = 1) => ({+ url,+ functions: [+ { functionName: '', ranges: [{ startOffset: 0, endOffset: 100, count: 1 }] },+ { functionName: 'f', ranges: [{ startOffset: 10, endOffset: 20, count }] },+ ],+});++describe('browser coverage to recorded files', () => {+ test('scripts whose functions ran map to their source files, once each, sorted', () => {+ expect(+ browserCoverageFiles(+ [+ ran('http://127.0.0.1:4100/src/main.tsx?t=1'),+ ran('http://127.0.0.1:4100/src/main.tsx?t=2'),+ ran(+ 'http://127.0.0.1:4100/@fs/work/My%20Repo/public/open-knowledge/packages/core/src/index.ts',+ ),+ ran('http://127.0.0.1:4100/src/editor/Idle.tsx', 0),+ ran('http://127.0.0.1:4100/node_modules/.vite/deps/react.js'),+ ran('http://127.0.0.1:4100/@fs/tmp/ok-w0-vite/deps/yjs.js'),+ ],+ APP_DIR,+ OK_ROOT,+ ),+ ).toEqual(['packages/app/src/main.tsx', 'packages/core/src/index.ts']);+ });+});++describe('coverage records', () => {+ test('a spec is named by its path under the Open Knowledge root', () => {+ expect(specPath(`${APP_DIR}/tests/stress/docs-open.e2e.ts`, OK_ROOT)).toBe(+ 'packages/app/tests/stress/docs-open.e2e.ts',+ );+ });++ test('a record is one JSON line', () => {+ const line = coverageRecordLine({+ schema: COVERAGE_RECORD_SCHEMA,+ spec: 'packages/app/tests/stress/docs-open.e2e.ts',+ title: 'opens > a doc',+ retry: 0,+ status: 'passed',+ browser: ['packages/app/src/main.tsx'],+ server: null,+ });+ expect(line.endsWith('\n')).toBe(true);+ expect(line.indexOf('\n')).toBe(line.length - 1);+ expect(JSON.parse(line)).toMatchObject({ schema: 'ok-e2e-coverage-record/1', server: null });+ });+});diff --git a/packages/app/tests/stress/_helpers/coverage/e2e-coverage.ts b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.tsnew file mode 100644index 000000000..d54278070--- /dev/null+++ b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.ts@@ -0,0 +1,180 @@+import { appendFileSync, mkdirSync } from 'node:fs';+import { join, relative, sep } from 'node:path';+import type { Browser, BrowserContext, CDPSession, Page, TestInfo } from '@playwright/test';+import {+ browserScriptFile,+ E2E_COVERAGE_PATH,+ e2eCoverageDir,+ executedOffsets,+ recordableSource,+ type ScriptCoverage,+} from '../../../../src/build/e2e-coverage-contract.ts';+import type { WorkerServer } from '../fixtures.ts';+import { APP_PACKAGE_ROOT } from '../seed-key.ts';++export const COVERAGE_RECORD_SCHEMA = 'ok-e2e-coverage-record/1';+const OK_ROOT = join(APP_PACKAGE_ROOT, '..', '..');+const SERVER_CALL_TIMEOUT_MS = 10_000;++export interface CoverageRecord {+ readonly schema: typeof COVERAGE_RECORD_SCHEMA;+ readonly spec: string;+ readonly title: string;+ readonly retry: number;+ readonly status: string;+ readonly browser: readonly string[];+ readonly server: readonly string[] | null;+}++export interface E2eCoverage {+ watchPage(page: Page): Promise<void>;+ watchContext(context: BrowserContext): void;+ collectPage(page: Page): Promise<void>;+}++export const NO_COVERAGE: E2eCoverage = {+ watchPage: async () => {},+ watchContext: () => {},+ collectPage: async () => {},+};++export function browserCoverageFiles(+ scripts: readonly ScriptCoverage[],+ appDir: string,+ okRoot: string,+): string[] {+ const files = new Set<string>();+ for (const script of scripts) {+ if (executedOffsets(script).length === 0) continue;+ const file = browserScriptFile(script.url, appDir);+ const recorded = file === undefined ? undefined : recordableSource(file, okRoot);+ if (recorded !== undefined) files.add(recorded);+ }+ return [...files].sort();+}++export function coverageRecordLine(record: CoverageRecord): string {+ return `${JSON.stringify(record)}\n`;+}++export function specPath(testFile: string, okRoot: string = OK_ROOT): string {+ return relative(okRoot, testFile).split(sep).join('/');+}++class TestCoverage implements E2eCoverage {+ readonly browser = new Set<string>();+ private readonly sessions = new Map<Page, CDPSession>();++ async watchPage(page: Page): Promise<void> {+ if (this.sessions.has(page) || page.isClosed()) return;+ try {+ const session = await page.context().newCDPSession(page);+ await session.send('Profiler.enable');+ await session.send('Profiler.startPreciseCoverage', { callCount: false, detailed: false });+ this.sessions.set(page, session);+ } catch {+ return;+ }+ const close = page.close.bind(page);+ page.close = async (options) => {+ await this.collectPage(page);+ return close(options);+ };+ }++ watchContext(context: BrowserContext): void {+ context.on('page', (page) => {+ void this.watchPage(page);+ });+ const close = context.close.bind(context);+ context.close = async (options) => {+ await this.collectAll(context.pages());+ return close(options);+ };+ }++ async collectPage(page: Page): Promise<void> {+ const session = this.sessions.get(page);+ if (session === undefined) return;+ this.sessions.delete(page);+ try {+ const { result } = await session.send('Profiler.takePreciseCoverage');+ for (const file of browserCoverageFiles(result, APP_PACKAGE_ROOT, OK_ROOT))+ this.browser.add(file);+ await session.detach();+ } catch {+ return;+ }+ }++ async collectAll(pages: readonly Page[] = [...this.sessions.keys()]): Promise<void> {+ for (const page of pages) await this.collectPage(page);+ }+}++async function serverCoverage(baseURL: string, op: 'reset' | 'take'): Promise<string[] | null> {+ try {+ const res = await fetch(`${baseURL}${E2E_COVERAGE_PATH}?op=${op}`, {+ method: 'POST',+ signal: AbortSignal.timeout(SERVER_CALL_TIMEOUT_MS),+ });+ if (!res.ok) return null;+ const body = (await res.json()) as { files?: unknown };+ return Array.isArray(body.files)+ ? body.files.filter((file): file is string => typeof file === 'string')+ : null;+ } catch {+ return null;+ }+}++export async function recordingCoverage(+ { browser, workerServer }: { browser: Browser; workerServer: WorkerServer },+ use: (coverage: E2eCoverage) => Promise<void>,+ testInfo: TestInfo,+): Promise<void> {+ const dir = e2eCoverageDir(process.env);+ if (dir === undefined) {+ await use(NO_COVERAGE);+ return;+ }+ const coverage = new TestCoverage();+ const newContext = browser.newContext;+ browser.newContext = async (options) => {+ const context = await newContext.call(browser, options);+ coverage.watchContext(context);+ return context;+ };+ const reset = await serverCoverage(workerServer.baseURL, 'reset');+ try {+ await use(coverage);+ } finally {+ browser.newContext = newContext;+ await coverage.collectAll();+ const server = reset === null ? null : await serverCoverage(workerServer.baseURL, 'take');+ mkdirSync(dir, { recursive: true });+ appendFileSync(+ join(dir, `coverage-${process.pid}.jsonl`),+ coverageRecordLine({+ schema: COVERAGE_RECORD_SCHEMA,+ spec: specPath(testInfo.file),+ title: testInfo.titlePath.slice(1).join(' > '),+ retry: testInfo.retry,+ status: testInfo.status ?? 'unknown',+ browser: [...coverage.browser].sort(),+ server,+ }),+ );+ }+}++export async function withoutCoverage(+ // biome-ignore lint/correctness/noEmptyPattern: Playwright fixture contract+ {}: object,+ use: (coverage: E2eCoverage) => Promise<void>,+): Promise<void> {+ await use(NO_COVERAGE);+}++export const coverageFixture =+ e2eCoverageDir(process.env) === undefined ? withoutCoverage : recordingCoverage;diff --git a/packages/app/tests/stress/_helpers/fixtures.ts b/packages/app/tests/stress/_helpers/fixtures.tsindex 5f05eea95..4f688d778 100644--- a/packages/app/tests/stress/_helpers/fixtures.ts+++ b/packages/app/tests/stress/_helpers/fixtures.ts@@ -4,6 +4,7 @@ import { join } from 'node:path';import type { ProblemType } from '@inkeep/open-knowledge-core';import { test as base } from '@playwright/test';import { resetContentToFixtureBaseline } from './content-reset.ts';+import { coverageFixture, type E2eCoverage } from './coverage/e2e-coverage.ts';import { gotoWhileLoadProgresses, requireDeadlineAt } from './load-progress.ts';import { type WorkerServing, workerServingFor } from './prebuilt/prebuilt-serving.ts';import {@@ -100,6 +101,7 @@ type WorkerFixtures = {type TestFixtures = {api: ApiHelpers;serverLeaseCheck: undefined;+ e2eCoverage: E2eCoverage;};export const WORKER_SERVER_BUDGET_TOTAL_MS = 240_000;@@ -516,6 +518,13 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({workerServerEnv: [{}, { scope: 'worker', option: true }],serverLease: [leaseWorkerServer, { scope: 'worker', timeout: WORKER_SERVER_BUDGET_TOTAL_MS }],serverLeaseCheck: [checkServerLease, { auto: true }],+ e2eCoverage: [coverageFixture, { auto: true }],+ page: async ({ page, e2eCoverage }, use) => {+ e2eCoverage.watchContext(page.context());+ await e2eCoverage.watchPage(page);+ await use(page);+ await e2eCoverage.collectPage(page);+ },workerServer: [async ({ workerServerEnv, browser, serverLease }, use, workerInfo) => {if (serverLease?.kind === 'leased') {diff --git a/packages/app/tsconfig.json b/packages/app/tsconfig.jsonindex 4794852b0..b54de44f3 100644--- a/packages/app/tsconfig.json+++ b/packages/app/tsconfig.json@@ -94,6 +94,7 @@"tests/stress/_helpers/boot-verdict","tests/stress/_helpers/card-surface.ts","tests/stress/_helpers/corner-stack.ts",+ "tests/stress/_helpers/coverage","tests/stress/_helpers/editor-state.ts","tests/stress/_helpers/feedback-nudge.ts","tests/stress/_helpers/image.ts",diff --git a/packages/app/vite.config.ts b/packages/app/vite.config.tsindex 764281ae0..5a29d313c 100644--- a/packages/app/vite.config.ts+++ b/packages/app/vite.config.ts@@ -1,8 +1,11 @@+import { join } from 'node:path';import babel from '@rolldown/plugin-babel';import react from '@vitejs/plugin-react';import { defineConfig } from 'vite';import { injectAppVersionEnv } from './src/build/app-version';import { chromeTokensVitePlugin } from './src/build/chrome-tokens-vite-plugin';+import { e2eCoverageDir } from './src/build/e2e-coverage-contract';+import { e2eCoveragePlugin } from './src/build/e2e-coverage-plugin';import { rejectionLoopGuardPlugin } from './src/build/rejection-loop-guard-plugin';import { testLoopMarkerPlugin } from './src/build/test-loop-marker-plugin';import { TEST_SERVER_STARTUP_ENV } from './src/build/test-server-startup-contract';@@ -77,7 +80,13 @@ export default defineConfig({hocuspocusPlugin(),...(startupRequest === undefined? []- : [testServerStartupPlugin(startupRequest), testLoopMarkerPlugin()]),+ : [+ testServerStartupPlugin(startupRequest),+ testLoopMarkerPlugin(),+ ...(e2eCoverageDir(process.env) === undefined+ ? []+ : [e2eCoveragePlugin(join(import.meta.dirname, '../..'))]),+ ]),],resolve: {tsconfigPaths: true,diff --git a/turbo.json b/turbo.jsonindex 84b5cefc0..939cc9d75 100644--- a/turbo.json+++ b/turbo.json@@ -303,12 +303,12 @@"test:e2e": {"dependsOn": ["^build", "build"],"cache": false,- "passThroughEnv": ["OK_TEST_E2E_SERVING"]+ "passThroughEnv": ["OK_TEST_E2E_SERVING", "OK_E2E_COVERAGE_DIR"]},"@inkeep/open-knowledge-app#test:e2e": {"dependsOn": ["^build", "build", "@inkeep/open-knowledge#build"],"cache": false,- "passThroughEnv": ["OK_TEST_E2E_SERVING"]+ "passThroughEnv": ["OK_TEST_E2E_SERVING", "OK_E2E_COVERAGE_DIR"]},"test:perf": {"dependsOn": [],