import { createHash } from "node:crypto"; import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs"; import { readFile } from "node:fs/promises"; import { createServer } from "node:http"; import { tmpdir } from "node:os"; import path from "node:path"; import { fileURLToPath } from "node:url"; import { expect, type Page, type Request, type Response, test, } from "@playwright/test"; import { parseSync } from "oxc-parser"; import { observeDocumentDepartures } from "../../../test/browser-departures.ts"; import { type BrowserDiagnostics, emitBrowserFailureDiagnostics, observeBrowserDiagnostics, } from "../../../test/browser-diagnostics.ts"; const boardRuntime: typeof import("../board-runtime.ts") = await import( new URL("../../../dist/the-system/board-runtime.ts", import.meta.url).href ); const systemCommand: typeof import("../system-command.ts") = await import( new URL("../../../dist/the-system/system-command.ts", import.meta.url).href ); const { createBoardRuntime } = boardRuntime; const { createSystemCommand } = systemCommand; const roots: string[] = []; const runtimes: ReturnType[] = []; const health = new Map< Page, { errors: string[]; requestErrors: Map; nativeMediaHandoffs: WeakSet; expected: Map; expectedPageErrors: RegExp[]; resourceResponses: Map; resourceErrors: string[]; diagnostics: BrowserDiagnostics; finalizeDepartures: () => Promise; } >(); test.beforeEach(({ page }) => observeHealth(page)); function observeHealth(page: Page) { const state = { errors: [] as string[], requestErrors: new Map(), nativeMediaHandoffs: new WeakSet(), expected: new Map(), expectedPageErrors: [] as RegExp[], resourceResponses: new Map(), resourceErrors: [] as string[], diagnostics: observeBrowserDiagnostics(page), finalizeDepartures: async () => {}, }; health.set(page, state); page.on("pageerror", (error) => { const index = state.expectedPageErrors.findIndex((pattern) => pattern.test(error.message), ); if (index >= 0) state.expectedPageErrors.splice(index, 1); else state.errors.push(`pageerror: ${error.message}`); }); page.on("console", (message) => { if (message.type() !== "error") return; if (!message.text().startsWith("Failed to load resource:")) { state.errors.push(`console: ${message.text()}`); return; } const source = message.location().url; const path = source ? new URL(source).pathname : ""; const remaining = state.resourceResponses.get(path) ?? 0; if (remaining > 0) state.resourceResponses.set(path, remaining - 1); else state.resourceErrors.push(`${message.text()} ${source}`); }); page.on("response", (response) => { if (response.status() < 400) return; const pathname = new URL(response.url()).pathname; const key = `${pathname}:${response.status()}`; if (consumeExpected(state, key)) state.resourceResponses.set( pathname, (state.resourceResponses.get(pathname) ?? 0) + 1, ); else state.errors.push(`HTTP ${response.status()}: ${response.url()}`); }); state.finalizeDepartures = observeDocumentDepartures(page, (request) => { const key = `${new URL(request.url()).pathname}:failed`; if (consumeExpected(state, key)) { const pathname = new URL(request.url()).pathname; state.resourceResponses.set( pathname, (state.resourceResponses.get(pathname) ?? 0) + 1, ); } else { if (state.requestErrors.size >= 512) throw new Error("Browser request-failure limit exceeded"); state.requestErrors.set( request, `requestfailed: ${request.url()} ${request.failure()?.errorText}`, ); } }); } test.afterEach(async ({ context: _context }, info) => { let healthy = false; try { for (const state of health.values()) { await state.finalizeDepartures(); expect( [...state.requestErrors] .filter(([request]) => !state.nativeMediaHandoffs.has(request)) .map(([, error]) => error), ).toEqual([]); expect(state.errors).toEqual([]); expect(state.resourceErrors).toEqual([]); expect( [...state.expected.entries()].filter(([, count]) => count > 0), ).toEqual([]); expect(state.expectedPageErrors).toEqual([]); } healthy = true; } finally { if (!healthy || info.status !== info.expectedStatus) await emitBrowserFailureDiagnostics( "the-system", info, [...health.values()].map((state) => state.diagnostics), ); health.clear(); } }); test.afterEach(() => { for (const runtime of runtimes.splice(0)) runtime.shutdown(); for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); }); test("health scopes aborts to confirmed document departures, not active, hash, or rejected navigations", async ({ context, browserName, }) => { test.skip( browserName !== "chromium", "Chromium ERR_ABORTED ownership contract", ); for (const mode of ["depart", "active", "hash", "rejected"] as const) { const held = Promise.withResolvers(); const server = createServer((request, response) => { if (request.url === "/held.js") { response.writeHead(200, { "content-type": "text/javascript" }); response.write("/* held module body */"); held.resolve(); } else { response.setHeader("content-type", "text/html"); response.end( request.url === "/replacement" ? "

Replacement

" : '

Original

', ); } }); await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve), ); const address = server.address(); if (!address || typeof address === "string") throw new Error("No fixture port"); const url = `http://127.0.0.1:${address.port}`; const current = await context.newPage(); const failures: string[] = []; const finalize = observeDocumentDepartures(current, (request) => failures.push(new URL(request.url()).pathname), ); const abort = Promise.withResolvers(); const intercepted = Promise.withResolvers(); try { if (mode !== "depart") await current.route("**/held.js", async (route) => { intercepted.resolve(); await abort.promise; await route.abort("aborted"); }); await current.goto(url, { waitUntil: "domcontentloaded" }); await (mode === "depart" ? held.promise : intercepted.promise); const failed = current.waitForEvent("requestfailed", (request) => request.url().endsWith("/held.js"), ); if (mode === "depart") await current.goto(`${url}/replacement`); else { if (mode === "hash") { await current.evaluate(() => { location.hash = "still-here"; }); await expect(current).toHaveURL(/#still-here$/); } if (mode === "rejected") { await current.route("**/blocked", (route) => route.abort("failed")); await expect(current.goto(`${url}/blocked`)).rejects.toThrow(); } abort.resolve(); } expect((await failed).failure()?.errorText).toBe("net::ERR_ABORTED"); await finalize(); if (mode === "depart") expect(failures).toEqual([]); else expect(failures).toContain("/held.js"); } finally { abort.resolve(); await current.close(); server.closeAllConnections(); await new Promise((resolve) => server.close(() => resolve())); } } }); test("/system view and book render rich System docs without source mutation", async ({ page, }, testInfo) => { const root = systemFixture(); const before = hashTree(path.join(root, ".system")); const runtime = createBoardRuntime(); const command = createSystemCommand({ sendUserMessage() {} } as never, { openBook: (cwd, page) => runtime.open(cwd, undefined, page), }); runtimes.push(runtime); const notices: string[] = []; const previousNodeEnv = process.env["NODE_ENV"]; process.env["NODE_ENV"] = "test"; try { await command.handler("view PX-SPEC-SPEC0001", ctx(root, notices)); await command.handler("view PX-PHASE-PHASE002", ctx(root, notices)); await command.handler("book", ctx(root, notices)); } finally { process.env["NODE_ENV"] = previousNodeEnv; } const view = urlFromNotice(notices[0] ?? ""); const phaseView = urlFromNotice(notices[1] ?? ""); const book = urlFromNotice(notices[2] ?? ""); expect(new URL(view).origin).toBe(new URL(book).origin); expect(new URL(phaseView).origin).toBe(new URL(book).origin); await page.goto(view); await expect( page.getByRole("heading", { name: "Contract" }).first(), ).toBeVisible(); await expect( page.locator("#PX-SPEC-SPEC0001").getByText("Metadata"), ).toBeVisible(); await expect(page.locator(".mermaid svg")).toBeVisible(); await expect(page.locator("math").first()).toBeVisible(); await expect(page.locator(".mermaid")).toBeVisible(); await expect(page.locator("iframe")).toHaveAttribute( "src", /\/\.system\/.*mockup-card\.html/, ); await expect(page.getByText("raw html works")).toBeVisible(); await page.goto(phaseView); await expect(page.locator(".phase-current")).toHaveText("Current phase"); await expect( page.getByRole("heading", { name: "Pre-v1" }).first(), ).toBeVisible(); await page.goto(book); await expect( page.getByRole("heading", { name: /the-system-render-e2e-.* Dossier/ }), ).toBeVisible(); await expect(page.getByRole("link", { name: "CORE-SYSTEM" })).toBeVisible(); await expect(page.locator("#PX-PHASE-PHASE002")).toBeVisible(); await expect(page.locator(".book-top .active-phase")).toHaveText( "Current phase pre-v1", ); await expect(page.locator('.book-nav a[aria-current="true"]')).toContainText( "PX-PHASE-PHASE002", ); const related = page .locator("#PX-SPEC-SPEC0001") .locator("details") .filter({ has: page.getByText("Referenced by", { exact: true }) }); await expect(related).toHaveCount(1); await related.locator("summary").click(); const buildBacklink = related.getByRole("link", { name: /Build/ }); await expect(buildBacklink).toBeVisible(); await expect(related.getByRole("link", { name: /Bug/ })).toBeVisible(); await buildBacklink.click(); await expect(page.locator("#PX-PLAN-PLAN0001")).toBeInViewport(); await expect( page.locator('a[href^="file:"][href*="PX-"][href$="index.html"]'), ).toHaveCount(0); await expect( page.locator('#PX-SPEC-SPEC0001 .ledger a[href="/#PX-RESEARCH-RSCH0001"]'), ).toHaveCount(1); const readingOrder = [ "CORE-MISSION", "PX-PHASE-PHASE002", "CORE-RULES", "PX-PHASE-PHASE001", "PX-SPEC-SPEC0001", "PX-PLAN-PLAN0001", "PX-PLAN-PLAN0002", "PX-ISSUE-ISSUE001", "PX-RESEARCH-RSCH0001", ]; const renderedOrder = await page .locator(".book-section") .evaluateAll((sections) => sections.map((section) => section.id)); expect(renderedOrder.filter((id) => readingOrder.includes(id))).toEqual( readingOrder, ); await assertSidebarConnected(page); await page.screenshot({ path: testInfo.outputPath("book-desktop.png") }); const graph = page.locator("[data-graph-svg]"); await expect(graph).toBeVisible(); await expect(graph.locator("a")).toHaveCount(5); await expect(graph.locator('a[href="#PX-PHASE-PHASE002"]')).toHaveCount(0); const initialViewBox = await graph.getAttribute("viewBox"); await graph.hover(); await page.mouse.wheel(0, -240); await expect(graph).not.toHaveAttribute("viewBox", initialViewBox ?? ""); await page.locator('[data-graph-zoom="reset"]').click(); await expect(graph).toHaveAttribute("viewBox", initialViewBox ?? ""); await page.locator('.book-nav a[href="/#PX-PHASE-PHASE002"]').click(); await expect(page.locator("#PX-PHASE-PHASE002")).toBeInViewport(); await expect(page).toHaveURL(/#PX-PHASE-PHASE002$/); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); await assertSidebarConnected(page); await page.locator('.book-nav a[href="/#PX-SPEC-SPEC0001"]').click(); await expect(page.locator("#PX-SPEC-SPEC0001")).toBeInViewport(); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); const ledger = page.locator("#PX-SPEC-SPEC0001 .ledger"); await expect(ledger).not.toHaveAttribute("open", ""); await ledger .locator("summary") .evaluate((element) => (element as HTMLElement).click()); await expect(ledger).toHaveAttribute("open", ""); const researchLink = ledger.locator('a[href="/#PX-RESEARCH-RSCH0001"]'); await researchLink.evaluate((element) => element.scrollIntoView({ behavior: "instant", block: "center" }), ); await expect(researchLink).toBeVisible(); await researchLink.click(); await expect(page.locator("#PX-RESEARCH-RSCH0001")).toBeInViewport(); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); await page.mouse.wheel(0, 1200); await assertSidebarConnected(page); await page.goto(book); await page.setViewportSize({ width: 390, height: 844 }); await expect(page.locator(".book-nav")).toBeHidden(); await expect(page.locator(".mobile-nav")).toBeVisible(); await expect(page.locator(".mobile-nav > details")).not.toHaveAttribute( "open", "", ); await expect(page.locator(".graph-frame")).toBeVisible(); await page.screenshot({ path: testInfo.outputPath("book-mobile.png") }); await page.locator('[data-graph-zoom="in"]').click(); await expect(graph).not.toHaveAttribute("viewBox", initialViewBox ?? ""); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); await page.locator("#search").fill("body-only-term"); await expect(page.locator("#results")).toContainText("PX-SPEC-SPEC0001"); await expect(page.locator("#results")).toContainText("body-only-term"); expect( ( await page.request.get( new URL( "/.system/specs/PX-SPEC-SPEC0001-contract/mockup-card.html", book, ).href, ) ).ok(), ).toBe(true); expect(hashTree(path.join(root, ".system"))).toBe(before); }); test("book serves one self-contained patched Mermaid bundle and sanitizes diagram labels", async ({ page, }) => { const root = systemFixture(); expectHealth(page, "/x:404", 2); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; write( root, spec, readFileSync(path.join(root, spec), "utf8") + '\n\n```mermaid\nflowchart TD\n A[""]\n```\n', ); const runtime = createBoardRuntime(); runtimes.push(runtime); const url = urlFromNotice(await runtime.open(root, undefined, "/")); const external: string[] = []; page.on("request", (request) => { if ( !request.url().startsWith(new URL(url).origin) && !request.url().startsWith("data:") ) external.push(request.url()); }); await page.goto(url); await expect(page.locator(".mermaid svg")).toHaveCount(2); await expect(page.locator(".mermaid [onerror], .mermaid script")).toHaveCount( 0, ); expect(await page.evaluate("window.diagramAttack")).toBeUndefined(); expect(external).toEqual([]); const pending = [new URL("/browser/book.js", url).href]; const seen = new Set(); let sanitizer = false; while (pending.length) { const file = pending.pop() as string; if (seen.has(file)) continue; seen.add(file); expect(seen.size).toBeLessThan(256); const response = await page.request.get(file); expect(response.ok(), file).toBe(true); expect(response.headers()["content-type"]).toContain("javascript"); const source = await response.text(); expect(source).not.toMatch( /DOMPurify(?:\.version\s*=\s*|\s+)['"]?3\.4\.12/, ); if (/DOMPurify\.version\s*=\s*['"]3\.4\.17/.test(source)) sanitizer = true; for (const dependency of moduleDependencies(source)) { expect(dependency.startsWith("."), dependency).toBe(true); pending.push(new URL(dependency, file).href); } } expect(sanitizer).toBe(true); expect(seen.size).toBe(1); }); for (const release of [false, true]) { test( "book renders multiple diagram families without fetching implementation chunks (release: " + release + ")", async ({ page }) => { const root = systemFixture(); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; const diagrams = [ "sequenceDiagram\n Alice->>Bob: Hello", "classDiagram\n class Widget", "stateDiagram-v2\n [*] --> Ready", 'pie title Shares\n "A": 2\n "B": 1', ]; write( root, spec, readFileSync(path.join(root, spec), "utf8") + diagrams .map( (diagram) => '\n\n
' + diagram + "
\n", ) .join(""), ); const runtime = createBoardRuntime(); runtimes.push(runtime); if (release) { // Build tooling stays outside the extension's composite TS project. const { bundleBrowserEntries } = await import( new URL("../../../scripts/build/bundle.ts", import.meta.url).href ); const { readBuildSpec } = await import( new URL("../../../scripts/build/spec.ts", import.meta.url).href ); const artifact = mkdtempSync( path.join(tmpdir(), "system-release-browser-"), ); roots.push(artifact); await bundleBrowserEntries( readBuildSpec(fileURLToPath(new URL("../", import.meta.url))), artifact, { release: true }, ); const directory = path.join(artifact, "browser"); expect( readdirSync(directory).filter((file) => file.endsWith(".js")), ).toEqual(["book.js"]); const body = await readFile(path.join(directory, "book.js")); await page.route("**/browser/book.js", (route) => route.fulfill({ status: 200, contentType: "text/javascript", body, }), ); } const scripts = new Set(); page.on("request", (request) => { if ( request.resourceType() === "script" && request.frame() === page.mainFrame() ) scripts.add(new URL(request.url()).pathname); }); await page.goto(urlFromNotice(await runtime.open(root, undefined, "/"))); await expect( page.locator('.mermaid[data-processed="true"] > svg'), ).toHaveCount(5); for (const label of ["Alice", "Widget", "Ready", "Shares"]) await expect( page.locator(".mermaid").filter({ hasText: label }), ).toHaveCount(1); expect([...scripts]).toEqual(["/browser/book.js"]); await page.locator("#search").fill("body-only-term"); await page.locator("#search-button").click(); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); }, ); } test("book refresh retains location/search and keeps the last good page after invalid config", async ({ page, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); runtimes.push(runtime); await page.goto( urlFromNotice(await runtime.open(root, undefined, "/#PX-SPEC-SPEC0001")), ); await page.locator("#search").fill("body-only-term"); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; const source = readFileSync(path.join(root, spec), "utf8"); const navigation = page .locator(".book-nav details") .filter({ has: page.locator('a[href="/#PX-PLAN-PLAN0001"]') }); await navigation.locator("summary").click(); await expect(navigation).toHaveAttribute("open", ""); await expect(page.locator(".mermaid svg")).toHaveCount(1); await page.evaluate(() => scrollBy({ top: 120, behavior: "instant" })); const before = await page.evaluate(() => scrollY); write(root, spec, source + "\n\nBook changed on disk.\n"); await expect( page.getByText("Book changed on disk.", { exact: true }), ).toBeVisible({ timeout: 15000 }); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); await expect(page.locator("#search")).toHaveValue("body-only-term"); await expect(navigation).toHaveAttribute("open", ""); await expect(page.locator("#results")).toContainText("body-only-term"); await expect(page.locator("#results")).toContainText("PX-SPEC-SPEC0001"); await expect(page.locator(".mermaid svg")).toHaveCount(1); await expect .poll(async () => Math.abs((await page.evaluate(() => scrollY)) - before)) .toBeLessThan(60); const revision = await page.locator("body").getAttribute("data-revision"); const config = readFileSync(path.join(root, ".system/config.json"), "utf8"); write(root, ".system/config.json", "{"); await expect(page.locator("[data-board-notice]")).toHaveClass(/is-error/, { timeout: 15000, }); await expect(page.locator("body")).toHaveAttribute( "data-revision", revision as string, ); await expect( page.getByText("Book changed on disk.", { exact: true }), ).toBeVisible(); write(root, ".system/config.json", config); write(root, spec, source + "\n\nBook recovered.\n"); await expect(page.getByText("Book recovered.", { exact: true })).toBeVisible({ timeout: 15000, }); }); test("/system board persists independent spec, plan, and issue assessments", async ({ page, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); try { await runtime.tool.execute( "assessment", { items: [ { id: "PX-ISSUE-ISSUE001", state: "done", rationale: "The reproduction no longer fails.", }, ], }, new AbortController().signal, undefined, { cwd: root } as never, ); const notice = await runtime.open(root); expect(notice).toContain("Browser: Browser opener disabled"); const url = notice.match( /http:\/\/127\.0\.0\.1:\d+\/board\.html\?k=[^\s]+/, )?.[0]; expect(url).toBeTruthy(); await page.goto(url ?? ""); const spec = page.locator('[data-board-item][data-id="PX-SPEC-SPEC0001"]'); const planA = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); const planB = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0002"]'); const issue = page.locator( '[data-board-item][data-id="PX-ISSUE-ISSUE001"]', ); await expect(spec).toBeVisible(); await expect(planA).toBeVisible(); await expect(planB).toBeVisible(); await expect(issue.locator("[data-proposal]")).toContainText( "The reproduction no longer fails.", ); await issue.locator("[data-apply-proposal]").click(); await expect(issue).toHaveClass(/is-done/); await expect(issue.locator("[data-assessment]")).toContainText("assess"); await spec.locator(":scope > .board-row > .board-bundle > summary").click(); const specDetails = spec.locator( ":scope > .board-row > .board-bundle > .board-details", ); await expect(specDetails).toContainText("body-only-term"); await expect(specDetails.locator(".ledger")).toContainText("Metadata"); await expect( spec.locator(":scope > .board-row > .board-actions > .board-state"), ).toBeDisabled(); await planA.locator(".board-state").click(); await expect(planA).toHaveClass(/is-done/); await planB.locator(".board-state").click(); await expect(planB).toHaveClass(/is-done/); await expect( spec.locator(":scope > .board-row > .board-actions > .board-state"), ).toBeEnabled(); await spec .locator(":scope > .board-row > .board-actions > .board-state") .click(); await expect(spec).toHaveClass(/is-done/); await spec .locator(":scope > .board-row > .board-actions > .board-state") .click(); await expect(spec).not.toHaveClass(/is-done/); await expect(planA).toHaveClass(/is-done/); await expect(planB).toHaveClass(/is-done/); await spec .locator(":scope > .board-row > .board-actions > .board-state") .click(); await planA.locator(".board-state").click(); await expect(spec).not.toHaveClass(/is-done/); await expect(planA).not.toHaveClass(/is-done/); await expect(planB).toHaveClass(/is-done/); const board = JSON.parse( readFileSync(path.join(root, ".system/board.json"), "utf8"), ); expect(board.items["PX-ISSUE-ISSUE001"].source).toBe("assess"); expect(board.items["PX-SPEC-SPEC0001"].state).toBe("todo"); expect(board.items["PX-PLAN-PLAN0001"].state).toBe("todo"); expect(board.items["PX-PLAN-PLAN0002"].state).toBe("done"); await page.setViewportSize({ width: 390, height: 844 }); const specsBox = await page.locator(".board-spec-list").boundingBox(); const issuesBox = await page.locator(".board-issue-list").boundingBox(); if (!specsBox || !issuesBox) throw new Error("Board lists must remain visible"); expect(issuesBox.y).toBeGreaterThanOrEqual(specsBox.y + specsBox.height); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); } finally { runtime.shutdown(); } }); test("/system board keeps controls disabled until live state initializes", async ({ page, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); await runtime.tool.execute( "proposal", { items: [ { id: "PX-ISSUE-ISSUE001", state: "done", rationale: "Delayed readiness regression", }, ], }, new AbortController().signal, undefined, { cwd: root } as never, ); const initialPoll = Promise.withResolvers(); await page.route("**/api/state", async (route) => { if (route.request().method() === "GET") await initialPoll.promise; await route.continue(); }); try { const notice = await runtime.open(root); const url = notice.match( /http:\/\/127\.0\.0\.1:\d+\/board\.html\?k=[^\s]+/, )?.[0]; expect(url).toBeTruthy(); await page.goto(url ?? ""); const plan = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); const state = plan.locator( ":scope > .board-row > .board-actions > .board-state", ); const status = plan.locator( ":scope > .board-row .ledger [data-status-toggle]", ); const assessment = page .locator('[data-board-item][data-id="PX-SPEC-SPEC0001"]') .locator(":scope > .board-row .ledger [data-board-toggle]"); await expect(state).toBeDisabled(); await expect(status).toBeDisabled(); await expect(assessment).toBeDisabled(); const apply = page.locator("[data-apply-proposal]"); await expect(apply).toBeDisabled(); // A mutation response can establish known state before the delayed poll. await page.evaluate(() => { const book = globalThis as typeof globalThis & { systemBoardSeen(items: Record): void; }; book.systemBoardSeen({}); }); initialPoll.resolve(); await expect(state).toBeEnabled(); await expect(status).toBeEnabled(); await expect(assessment).toBeEnabled(); await expect(apply).toBeEnabled(); await expect(page.locator("body")).toHaveAttribute( "data-live-ready", "true", ); await state.click(); await expect(state).toHaveText("DONE"); } finally { initialPoll.resolve(); await runtime.shutdown(); } }); test("/system board keeps terminal exec disabled and drop in metadata", async ({ page, }, testInfo) => { const runtime = createBoardRuntime(); try { const notice = await runtime.open(systemFixture()); await page.goto( notice.match(/http:\/\/127\.0\.0\.1:\d+\/board\.html\?k=[^\s]+/)?.[0] ?? "", ); const plan = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); const exec = plan.locator("[data-exec]"); const drop = plan.locator(":scope > .board-metadata > [data-drop]"); await expect(exec).toBeEnabled(); await expect(drop).toHaveText("DROP"); await expect(page.locator(".mermaid svg.flowchart")).toHaveCount(1); await plan.locator(".board-state").click(); await expect(exec).toBeDisabled(); await page.reload(); await expect(exec).toBeDisabled(); await expect(page.locator(".mermaid svg.flowchart")).toHaveCount(1); await expect(drop).toBeEnabled(); await plan.locator(".board-state").click(); await expect(exec).toBeEnabled(); await drop.click(); await expect(exec).toBeDisabled(); await expect(drop).toHaveText("RESTORE"); await drop.click(); await expect(exec).toBeEnabled(); await expect(drop).toHaveText("DROP"); await page.screenshot({ path: testInfo.outputPath("board.png"), fullPage: true, }); } finally { await runtime.shutdown(); } }); test("/system board survives refresh, follows disk changes, and toggles metadata", async ({ page, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); runtimes.push(runtime); const notice = await runtime.open(root); const url = notice.match( /http:\/\/127\.0\.0\.1:\d+\/board\.html\?k=[^\s]+/, )?.[0]; await page.goto(url ?? ""); // Explicit refresh must follow observable renderer completion, not load alone. await expect(page.locator(".mermaid svg .node")).toHaveCount(2); const spec = page.locator('[data-board-item][data-id="PX-SPEC-SPEC0001"]'); const planA = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); const planB = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0002"]'); await planA.locator(".board-state").click(); await expect(planA).toHaveClass(/is-done/); await page.reload(); await expect(page.locator(".mermaid svg .node")).toHaveCount(2); await expect(planA).toHaveClass(/is-done/); await expect(planB).not.toHaveClass(/is-done/); const planLedger = planB.locator(":scope > .board-row .ledger"); await planB.locator(":scope > .board-row > .board-bundle > summary").click(); await planLedger.locator("summary").click(); await spec.locator(":scope > .board-row > .board-bundle > summary").click(); const specLedger = spec.locator(":scope > .board-row .ledger"); await specLedger.locator("summary").click(); write( root, ".system/issues/PX-ISSUE-ISSUE002-later/index.md", "---\nid: PX-ISSUE-ISSUE002\ntype: issue\ntitle: Later\nspecs: [PX-SPEC-SPEC0001]\n---\n\n# Later\n", ); const late = page.locator('[data-board-item][data-id="PX-ISSUE-ISSUE002"]'); await expect(late).toBeVisible({ timeout: 15000 }); // Polling reloads the whole document; visibility may precede script binding. await page.waitForLoadState("load"); await expect .poll(() => page.evaluate("typeof globalThis.systemBoardSeen")) .toBe("function"); await expect( planB.locator(":scope > .board-row > .board-bundle"), ).toHaveAttribute("open", ""); await expect(planLedger).toHaveAttribute("open", ""); await expect( spec.locator(":scope > .board-row > .board-bundle"), ).toHaveAttribute("open", ""); await expect(specLedger).toHaveAttribute("open", ""); const [statusResponse] = await Promise.all([ page.waitForResponse( (response) => response.url().endsWith("/api/status") && response.request().method() === "POST", ), planLedger.locator("[data-status-toggle]").click(), ]); expect(statusResponse.ok(), await statusResponse.text()).toBe(true); expect( readFileSync( path.join(root, ".system/plans/PX-PLAN-PLAN0002-test/index.md"), "utf8", ), ).toContain("status: approved"); const snapshot = await page.request.get( new URL("/api/state", page.url()).href, ); expect((await snapshot.json()).problem).toBeUndefined(); await expect( planB.locator(":scope > .board-row > .board-bundle > summary"), ).toContainText("approved", { timeout: 15000 }); await planB.locator(".board-state").click(); await expect(planB).toHaveClass(/is-done/); const boardToggle = specLedger.locator("[data-board-toggle]"); await expect(boardToggle).toHaveText("todo"); await boardToggle.click(); await expect(boardToggle).toHaveText("done"); await expect(spec).toHaveClass(/is-done/); const board = JSON.parse( readFileSync(path.join(root, ".system/board.json"), "utf8"), ); expect(board.items["PX-SPEC-SPEC0001"].state).toBe("done"); }); test("keyboard search, heading links, encoded previews, and mobile navigation", async ({ page, }, testInfo) => { const root = systemFixture(); const bundle = ".system/specs/PX-SPEC-SPEC0001-contract/"; write( root, `${bundle}space card.htm`, "Encoded card

Encoded preview

", ); write( root, `${bundle}space image.svg`, '', ); write( root, `${bundle}index.md`, readFileSync(path.join(root, bundle, "index.md"), "utf8") + "\n\n## Local heading\n\n[Local anchor](#local-heading)\n\n[Build heading](../../plans/PX-PLAN-PLAN0001-build/index.md#build)\n\n[Encoded card](./space%20card.htm)\n\n[Encoded image](./space%20image.svg)\n", ); const runtime = createBoardRuntime(); runtimes.push(runtime); await page.goto(urlFromNotice(await runtime.open(root, undefined, "/"))); await expect( page.getByRole("searchbox", { name: "Search", exact: true }), ).toBeVisible(); await page.locator("#search").fill("body-only-term"); await page.screenshot({ path: testInfo.outputPath("search-desktop.png") }); await expect(page.locator("#results li").first()).toBeInViewport({ ratio: 1, }); await expect(page.locator("#results mark")).toContainText(["body-only-term"]); await page.locator("#search").press("Enter"); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); await expect( page.locator("#PX-SPEC-SPEC0001 mark[data-search-hit]"), ).toHaveText("body-only-term"); await expect(page.locator("#results li")).toHaveCount(0); await page.locator("#search").fill("Build"); await page.locator('#results a[href="/#PX-PLAN-PLAN0001"]').click(); await expect(page.locator("#PX-PLAN-PLAN0001")).toBeInViewport(); await page.locator("#search").fill("zzzznevermatcheszzzz"); await expect(page.locator("#results li")).toHaveCount(0); const unchanged = page.url(); await page.locator("#search").press("Enter"); await expect(page).toHaveURL(unchanged); await page.locator("#search").fill(""); await page.locator("#search").press("Enter"); await expect(page).toHaveURL(unchanged); await expect(page.locator("mark[data-search-hit]")).toHaveCount(0); await page.locator("#search").fill("body-only-term"); await page.locator("#search").press("Enter"); await expect( page.locator("#PX-SPEC-SPEC0001 mark[data-search-hit]"), ).toHaveText("body-only-term"); const spec = page.locator("#PX-SPEC-SPEC0001"); await spec.getByRole("link", { name: "Local anchor", exact: true }).click(); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001-local-heading$/); await expect( page.locator("#PX-SPEC-SPEC0001-local-heading"), ).toBeInViewport(); await expectUnoccludedByBookHeader(page, "#PX-SPEC-SPEC0001-local-heading"); await spec.getByRole("link", { name: "Build heading", exact: true }).focus(); await page.keyboard.press("Enter"); await expect(page).toHaveURL(/#PX-PLAN-PLAN0001-build$/); await expect(page.locator("#PX-PLAN-PLAN0001-build")).toBeInViewport(); await expectUnoccludedByBookHeader(page, "#PX-PLAN-PLAN0001-build"); await page.goBack(); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001-local-heading$/); const preview = spec.locator('iframe[title="Encoded card"]'); await expect(preview).toHaveCount(1); await expect( page .frameLocator('iframe[title="Encoded card"]') .getByRole("heading", { name: "Encoded preview" }), ).toBeVisible(); const image = spec.locator('img[alt="Encoded image"]'); await expect(image).toBeVisible(); await expect .poll(() => image.evaluate((img) => (img as HTMLImageElement).naturalWidth)) .toBe(80); const full = spec .locator(".visual-asset-html") .filter({ has: page.locator('iframe[title="Encoded card"]') }) .getByRole("link", { name: "Open full-size" }); await full.focus(); await page.keyboard.press("Enter"); await expect( page.getByRole("heading", { name: "Encoded preview" }), ).toBeVisible(); await page.goBack(); await spec .locator(".visual-asset-image") .getByRole("link", { name: "Open full-size" }) .focus(); await page.keyboard.press("Enter"); await expect(page).toHaveURL(/space%20image\.svg$/); await expect(page.locator("svg")).toHaveAttribute("width", "80"); await page.goBack(); await page.setViewportSize({ width: 390, height: 844 }); const navigation = page.locator(".mobile-nav > details"); await navigation.locator(":scope > summary").focus(); await page.keyboard.press("Enter"); await expect(navigation).toHaveAttribute("open", ""); const plansSummary = navigation .locator("details > summary") .filter({ hasText: "Plans" }); await plansSummary.focus(); await page.keyboard.press("Enter"); const destination = navigation.locator('a[href="/#PX-PLAN-PLAN0002"]'); await expect(destination).toBeVisible(); await destination.focus(); await page.keyboard.press("Enter"); await expect(page.locator("#PX-PLAN-PLAN0002")).toBeInViewport(); await page.locator("#search").fill("body-only-term"); await page.locator("#search-button").click(); await expect(page.locator("#PX-SPEC-SPEC0001")).toBeInViewport(); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); await expect.poll(() => page.evaluate(() => scrollX)).toBe(0); }); for (const mode of ["active", "cancelled", "hash-only"] as const) { test( "book reports active rendering failures after " + mode + " navigation", async ({ context }) => { const root = systemFixture(); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; write( root, spec, readFileSync(path.join(root, spec), "utf8") + '\n\nLeave\nStay\n\n
flowchart TD; this is invalid
\n', ); const runtime = createBoardRuntime(); runtimes.push(runtime); const url = urlFromNotice(await runtime.open(root, undefined, "/")); const current = await context.newPage(); observeHealth(current); const requested = Promise.withResolvers(); const release = Promise.withResolvers(); const diagnostics: string[] = []; current.on("pageerror", (error) => diagnostics.push(error.message)); await current.route("**/browser/book.js", async (route) => { requested.resolve(); await release.promise; await route.continue().catch(() => {}); }); if (mode === "cancelled") await current.addInitScript(() => { addEventListener("beforeunload", (event) => { event.preventDefault(); event.returnValue = ""; }); }); try { await current.goto(url, { waitUntil: "commit" }); await requested.promise; await expect(current.locator("#departure")).toBeVisible(); const origin = await current.evaluate(() => performance.timeOrigin); if (mode === "cancelled") { const dialog = current.waitForEvent("dialog"); const navigation = current .locator("#departure") .click({ noWaitAfter: true }); await (await dialog).dismiss(); await navigation; } else if (mode === "hash-only") { await current.locator("#hash-only").click(); await expect(current).toHaveURL(/#still-here$/); } expectPageError(current, /Parse error on line 1:/); const diagnostic = current.waitForEvent("pageerror"); release.resolve(); expect((await diagnostic).message).toContain("Parse error on line 1:"); expect(await current.evaluate(() => performance.timeOrigin)).toBe( origin, ); expect(diagnostics).toHaveLength(1); await expect(current.locator("#departure")).toBeVisible(); } finally { release.resolve(); } }, ); } test("book entry cancellation after confirmed document departure emits no runtime exception", async ({ context, }) => { const root = systemFixture(); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; write( root, spec, readFileSync(path.join(root, spec), "utf8") + '\n\nLeave\n', ); const runtime = createBoardRuntime(); runtimes.push(runtime); const url = urlFromNotice(await runtime.open(root, undefined, "/")); const current = await context.newPage(); observeHealth(current); expectHealth(current, "/browser/book.js:failed"); const requested = Promise.withResolvers(); const release = Promise.withResolvers(); const diagnostics: string[] = []; current.on("pageerror", (error) => diagnostics.push(error.message)); await current.route("**/browser/book.js", async (route) => { requested.resolve(route.request()); await release.promise; await route.continue().catch(() => {}); }); try { await current.goto(url, { waitUntil: "commit" }); const entry = await requested.promise; await expect(current.locator("#departure")).toBeVisible(); const origin = await current.evaluate(() => performance.timeOrigin); const failed = current.waitForEvent( "requestfailed", (request) => request === entry, ); // about: is not an authored link scheme; set the native test target after rendering. await current.locator("#departure").evaluate((anchor) => { anchor.setAttribute("href", "about:blank"); }); await current.locator("#departure").click(); await expect(current).toHaveURL("about:blank"); expect(await current.evaluate(() => performance.timeOrigin)).not.toBe( origin, ); release.resolve(); expect((await failed).failure()?.errorText).toBeTruthy(); expect(diagnostics).toEqual([]); } finally { release.resolve(); await current.close(); } }); for (const mode of ["active", "stopped"] as const) { test( "book exposes initial entry failure on " + mode + " document", async ({ context, browserName }) => { const browserDirectory = fileURLToPath( new URL("../../../dist/the-system/browser/", import.meta.url), ); const navigating = Promise.withResolvers(); const navigationClosed = Promise.withResolvers(); let closed = false; const server = createServer((request, response) => { const pathname = new URL(request.url ?? "/", "http://localhost") .pathname; if (pathname === "/pending-navigation") { response.on("close", () => { closed = true; navigationClosed.resolve(); }); navigating.resolve(); } else if (pathname === "/browser/book.js") { response.setHeader("content-type", "text/javascript"); void readFile(path.join(browserDirectory, "book.js")).then( (body) => { if (!response.destroyed) response.end(body); }, () => { if (!response.destroyed) { response.statusCode = 404; response.end(); } }, ); } else { response.setHeader("content-type", "text/html"); response.end( pathname === "/frame" ? "child" : '
flowchart TD; A-->B
', ); } }); await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve), ); const address = server.address(); if (!address || typeof address === "string") throw new Error("No fixture port"); const url = "http://127.0.0.1:" + address.port; const current = await context.newPage(); observeHealth(current); expectHealth(current, "/browser/book.js:failed"); const requested = Promise.withResolvers(); const failEntry = Promise.withResolvers(); const diagnostics: string[] = []; current.on("pageerror", (error) => diagnostics.push(error.message)); await current.addInitScript(() => { const failures: string[] = []; Object.defineProperty(window, "__entryFailures", { value: failures }); addEventListener( "error", (event) => { const target = event.target; if ( target instanceof HTMLScriptElement && target.src && new URL(target.src).pathname === "/browser/book.js" ) failures.push("entry"); }, true, ); }); await current.route("**/browser/book.js", async (route) => { requested.resolve(route.request()); await failEntry.promise; await route.abort("failed").catch(() => {}); }); try { await current.goto(url, { waitUntil: "commit" }); const entry = await requested.promise; await expect(current.frameLocator("iframe").locator("body")).toHaveText( "child", ); const origin = await current.evaluate(() => performance.timeOrigin); const failed = current.waitForEvent( "requestfailed", (request) => request === entry, ); if (mode === "stopped") { expectHealth(current, "/pending-navigation:failed"); await current.evaluate((destination) => { location.href = destination; }, url + "/pending-navigation"); await navigating.promise; expect(closed).toBe(false); if (browserName === "chromium") { // Page.evaluate waits for the pending navigation; native Stop must not. const cdp = await context.newCDPSession(current); try { await cdp.send("Page.stopLoading"); } finally { await cdp.detach(); } } else await current.evaluate(() => stop()); await navigationClosed.promise; } failEntry.resolve(); expect((await failed).failure()?.errorText).toBeTruthy(); // Explicit Stop cancels loading; Chromium does not emit a script error for that cancellation. // A genuine active load failure must still emit one in both engines. const entryErrors = mode === "stopped" && browserName === "chromium" ? [] : ["entry"]; await expect .poll(() => current.evaluate(() => Reflect.get(window, "__entryFailures")), ) .toEqual(entryErrors); expect(await current.evaluate(() => performance.timeOrigin)).toBe( origin, ); expect(diagnostics).toEqual([]); await expect(current.locator(".mermaid svg")).toHaveCount(0); } finally { failEntry.resolve(); await current.close(); server.closeAllConnections(); await new Promise((resolve) => server.close(() => resolve())); } }, ); } test("book scopes generated fragments without taking ownership of active raw HTML", async ({ page, }) => { const root = systemFixture(); write( root, ".system/SYSTEM.md", '
Core authored HTML.
\n\n# Core law\n\n[Core heading](#core-law)\n', ); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; write( root, spec, readFileSync(path.join(root, spec), "utf8") + [ "", "Footnote reference[^1].", "", "[^1]: Document-local note.", "", '
0custom fragment
', ].join("\n"), ); for (const relative of [ ".system/specs/PX-SPEC-SPEC0001-contract/index.md", ".system/plans/PX-PLAN-PLAN0001-build/index.md", ]) write( root, relative, readFileSync(path.join(root, relative), "utf8") + "\n\nFootnote reference[^2].\n\n[^2]: Document-local note.\n", ); const runtime = createBoardRuntime(); runtimes.push(runtime); await page.goto(urlFromNotice(await runtime.open(root, undefined, "/"))); const coreArticle = page.locator(".book-section#CORE-SYSTEM"); await expect(coreArticle.locator("#core-custom")).toHaveCount(1); await coreArticle .getByRole("link", { name: "Core heading", exact: true }) .click(); await expect(page).toHaveURL(/#CORE-SYSTEM-core-law$/); await expectUnoccludedByBookHeader(page, "#CORE-SYSTEM-core-law"); const specArticle = page.locator(".book-section#PX-SPEC-SPEC0001"); await specArticle.getByRole("button", { name: "increment" }).click(); await expect(specArticle.locator("#counter")).toHaveText("1"); expect( await specArticle.evaluate(() => ({ counter: document.getElementById("counter")?.id, paint: document.getElementById("paint")?.id, fill: document.getElementById("painted")?.getAttribute("fill"), use: document.getElementById("paint-copy")?.getAttribute("href"), fragment: document.getElementById("custom-nav")?.getAttribute("href"), })), ).toEqual({ counter: "counter", paint: "paint", fill: "url(#paint)", use: "#painted", fragment: "#custom-fragment", }); for (const id of ["PX-SPEC-SPEC0001", "PX-PLAN-PLAN0001"]) { const article = page.locator(`.book-section#${id}`); const reference = article.locator('sup a[href*="fn-"]'); const target = await reference.first().getAttribute("href"); expect(target).toMatch(new RegExp(`^#${id}-`)); await expect(article.locator(target ?? "#missing")).toContainText( "Document-local note", ); await expect(reference.first()).toHaveAttribute( "aria-describedby", `${id}-footnote-label`, ); await expect(article.locator(`#${id}-footnote-label`)).toHaveCount(1); const backlink = article.locator( `${target ?? "#missing"} a[href*="fnref-"]`, ); await expect(backlink).toHaveCount(1); await expect(backlink).toHaveAttribute("href", new RegExp(`^#${id}-`)); await reference.first().click(); expect(new URL(page.url()).hash).toBe(target); await expectUnoccludedByBookHeader(page, target ?? "#missing"); const referenceTarget = await backlink.getAttribute("href"); await backlink.click(); expect(new URL(page.url()).hash).toBe(referenceTarget); await expectUnoccludedByBookHeader(page, referenceTarget ?? "#missing"); } }); test("graph controls, bounded pan and zoom, and light/dark desktop/mobile renderings", async ({ page, browserName, }, testInfo) => { const root = systemFixture(); const video = await page.evaluate(async () => { const canvas = document.createElement("canvas"); canvas.width = 80; canvas.height = 40; const ctx = canvas.getContext("2d"); const stream = canvas.captureStream(10); const recorder = new MediaRecorder(stream, { mimeType: "video/webm;codecs=vp8", }); const chunks: Blob[] = []; const stopped = new Promise((resolve) => { recorder.ondataavailable = (event) => chunks.push(event.data); recorder.onstop = () => resolve(new Blob(chunks)); }); recorder.start(); for (let i = 0; i < 4; i++) { if (ctx) { ctx.fillStyle = i % 2 ? "purple" : "teal"; ctx.fillRect(0, 0, 80, 40); } await new Promise((resolve) => setTimeout(resolve, 100)); } recorder.stop(); const bytes = [...new Uint8Array(await (await stopped).arrayBuffer())]; for (const track of stream.getTracks()) track.stop(); return bytes; }); const bundle = ".system/specs/PX-SPEC-SPEC0001-contract/"; writeFileSync(testInfo.outputPath("clip.webm"), Buffer.from(video)); writeFileSync(path.join(root, bundle, "clip.webm"), Buffer.from(video)); write( root, `${bundle}index.md`, readFileSync(path.join(root, bundle, "index.md"), "utf8") + "\n\n[Clip](./clip.webm)\n\n```ts\nconst answer = 42;\n```\n\n| Key | Value |\n| --- | --- |\n| rich | Markdown |\n", ); const runtime = createBoardRuntime(); runtimes.push(runtime); const url = urlFromNotice(await runtime.open(root, undefined, "/")); let clipResponse: Response | undefined; page.on("response", (response) => { if (new URL(response.url()).pathname.endsWith("/clip.webm")) clipResponse = response; }); await page.addInitScript(() => { const observe = (video: HTMLVideoElement) => { const observed = video as HTMLVideoElement & { __mediaEvents?: unknown[]; }; if (observed.__mediaEvents) return; observed.__mediaEvents = []; for (const type of [ "loadstart", "loadedmetadata", "loadeddata", "canplay", "error", ]) video.addEventListener(type, () => observed.__mediaEvents?.push({ type, readyState: video.readyState, networkState: video.networkState, }), ); }; new MutationObserver((mutations) => { for (const mutation of mutations) for (const node of mutation.addedNodes) if (node instanceof HTMLVideoElement) observe(node); }).observe(document, { childList: true, subtree: true }); }); await page.goto(url); const graph = page.locator("[data-graph-svg]"); const initial = await graph.getAttribute("viewBox"); await page.locator('[data-graph-zoom="in"]').click(); await expect(graph).not.toHaveAttribute("viewBox", initial ?? ""); const zoomed = await graph.getAttribute("viewBox"); const box = await graph.boundingBox(); expect(box).not.toBeNull(); if (!box) throw new Error("Graph bounds unavailable"); await page.mouse.move(box.x + box.width - 4, box.y + box.height - 4); await page.mouse.down(); await page.mouse.move(box.x + box.width - 90, box.y + box.height - 90, { steps: 5, }); await page.mouse.up(); await expect(graph).not.toHaveAttribute("viewBox", zoomed ?? ""); await page.locator('[data-graph-zoom="out"]').click(); await page.locator('[data-graph-zoom="reset"]').click(); await expect(graph).toHaveAttribute("viewBox", initial ?? ""); await graph.hover(); await page.mouse.wheel(0, -200); await expect(graph).not.toHaveAttribute("viewBox", initial ?? ""); for (let i = 0; i < 20; i++) await page.locator('[data-graph-zoom="in"]').click(); const bounds = await graph.evaluate((svg) => ({ box: svg.getAttribute("viewBox")?.split(" ").map(Number) ?? [], w: Number((svg as SVGElement).dataset["worldWidth"]), h: Number((svg as SVGElement).dataset["worldHeight"]), })); const [x = -1, y = -1, w = 0, h = 0] = bounds.box; expect(x).toBeGreaterThanOrEqual(0); expect(y).toBeGreaterThanOrEqual(0); expect(w).toBeGreaterThanOrEqual(180); expect(h).toBeGreaterThanOrEqual(120); expect(x + w).toBeLessThanOrEqual(bounds.w + 0.01); expect(y + h).toBeLessThanOrEqual(bounds.h + 0.01); for (let i = 0; i < 20; i++) await page.locator('[data-graph-zoom="out"]').click(); await expect(graph).toHaveAttribute("viewBox", `0 0 ${bounds.w} ${bounds.h}`); await page.locator('[data-graph-zoom="reset"]').click(); if (browserName === "chromium") { const cdp = await page.context().newCDPSession(page); const cx = box.x + box.width / 2, cy = box.y + box.height - 8; await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [ { x: cx - 20, y: cy }, { x: cx + 20, y: cy }, ], }); await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [ { x: cx - 70, y: cy }, { x: cx + 70, y: cy }, ], }); await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [], }); await expect(graph).not.toHaveAttribute("viewBox", initial ?? ""); const pinched = await graph.getAttribute("viewBox"); await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x: cx, y: cy }], }); await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x: cx - 30, y: cy - 30 }], }); await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [], }); await expect(graph).not.toHaveAttribute("viewBox", pinched ?? ""); await cdp.detach(); } await page.locator('[data-graph-zoom="reset"]').click(); await graph.locator('a[href="#PX-SPEC-SPEC0001"]').click(); await expect(page.locator("#PX-SPEC-SPEC0001")).toBeInViewport(); const player = page.locator("video"); await player.scrollIntoViewIfNeeded(); const beforePlay = await player.evaluate((element) => { const video = element as HTMLVideoElement & { __mediaEvents?: unknown[] }; return { currentSrc: video.currentSrc, events: video.__mediaEvents, networkState: video.networkState, readyState: video.readyState, }; }); try { await player.evaluate((element) => (element as HTMLVideoElement).play()); await expect .poll(() => player.evaluate((element) => (element as HTMLVideoElement).readyState), ) .toBeGreaterThanOrEqual(2); } catch (cause) { try { const media = await player.evaluate((element) => { const video = element as HTMLVideoElement & { __mediaEvents?: unknown[]; }; return { currentSrc: video.currentSrc, error: video.error ? { code: video.error.code, message: video.error.message } : undefined, events: video.__mediaEvents, networkState: video.networkState, readyState: video.readyState, source: video.querySelector("source")?.src, }; }); const response = clipResponse ? { headers: await clipResponse.allHeaders(), status: clipResponse.status(), url: clipResponse.url(), bytes: (await clipResponse.body()).byteLength, } : undefined; writeFileSync( testInfo.outputPath("clip-diagnostics.json"), JSON.stringify({ beforePlay, media, response }, undefined, 2), ); } catch { // Preserve the readiness assertion when its diagnostic collection fails. } throw cause; } await expect .poll(() => player.evaluate((element) => (element as HTMLVideoElement).currentTime), ) .toBeGreaterThan(0); await expect(page.locator("code.language-ts")).toContainText("answer"); await expect(page.locator("math")).toBeVisible(); await page .locator(".visual-asset-video") .getByRole("link", { name: "Open full-size" }) .focus(); let fullSizeRequest: Request | undefined; const fullSizeSettled = Promise.withResolvers(); const captureFullSizeSettlement = (request: Request) => { if (request === fullSizeRequest) fullSizeSettled.resolve(request); }; page.on("requestfinished", captureFullSizeSettlement); page.on("requestfailed", captureFullSizeSettlement); const clipUrl = new URL(`/${bundle}clip.webm`, url).href; const captureFullSizeRequest = (request: Request) => { if ( request.isNavigationRequest() && request.frame() === page.mainFrame() && request.url() === clipUrl ) fullSizeRequest ??= request; }; page.on("request", captureFullSizeRequest); const embeddedOrigin = await page.evaluate(() => performance.timeOrigin); await page.keyboard.press("Enter"); await expect(page).toHaveURL(/clip\.webm$/); await expect .poll(() => page .locator("video") .evaluate((element) => (element as HTMLVideoElement).videoWidth), ) .toBe(80); const nativeMediaOrigin = await page.evaluate(() => performance.timeOrigin); expect(nativeMediaOrigin).not.toBe(embeddedOrigin); await expect .poll(() => page .locator("video") .evaluate((element) => (element as HTMLVideoElement).readyState), ) .toBeGreaterThanOrEqual(2); expect( await page.locator("video").evaluate((element) => ({ src: (element as HTMLVideoElement).currentSrc, error: (element as HTMLVideoElement).error?.code ?? null, })), ).toEqual({ src: clipUrl, error: null }); page.off("request", captureFullSizeRequest); for (const theme of ["light", "dark"] as const) { await page.emulateMedia({ colorScheme: theme }); for (const size of ["desktop", "mobile"] as const) { await page.setViewportSize( size === "desktop" ? { width: 1280, height: 900 } : { width: 390, height: 844 }, ); for (const mode of ["book", "board"] as const) { await page.goto( new URL(mode === "book" ? "/#PX-SPEC-SPEC0001" : "/board.html", url) .href, ); if (mode === "board") await page .locator( '[data-id="PX-SPEC-SPEC0001"] > .board-row > .board-bundle > summary', ) .click(); await expect(page.locator(".mermaid svg .node")).toHaveCount(2); await expect .poll(() => page.locator(".mermaid").evaluate((container) => { const bounds = container.getBoundingClientRect(); return [...container.querySelectorAll(".node")].every((node) => { const rect = node.getBoundingClientRect(); return ( rect.width > 0 && rect.height > 0 && rect.left >= bounds.left && rect.right <= bounds.right && rect.top >= bounds.top && rect.bottom <= bounds.bottom ); }); }), ) .toBe(true); await page.screenshot({ path: testInfo.outputPath(`${mode}-${theme}-${size}.png`), fullPage: mode === "board", }); if (mode === "book" && size === "mobile") { await page.evaluate(() => scrollTo(0, 0)); await page.screenshot({ path: testInfo.outputPath(`book-${theme}-mobile-top.png`), }); } } } } // The native media document's response stream can abort only when leaving it. // Inspect its terminal state after the successful return navigation, not before. expect(fullSizeRequest).toBeDefined(); if (!fullSizeRequest) throw new Error("Native media navigation was not observed"); const fullSizeResponse = await fullSizeRequest.response(); expect(fullSizeResponse?.status()).toBe(200); expect(await fullSizeSettled.promise).toBe(fullSizeRequest); page.off("requestfinished", captureFullSizeSettlement); page.off("requestfailed", captureFullSizeSettlement); expect(await page.evaluate(() => performance.timeOrigin)).not.toBe( nativeMediaOrigin, ); if (fullSizeRequest.failure()?.errorText === "net::ERR_ABORTED") { const state = health.get(page); if (!state) throw new Error("Health observer is not attached"); expect(state.requestErrors.has(fullSizeRequest)).toBe(true); state.nativeMediaHandoffs.add(fullSizeRequest); } }); test("board action dispatch, clipboard fixture, errors, and live proposal changes", async ({ page, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); runtimes.push(runtime); const executions: string[] = []; let executionError = false; const url = urlFromNotice( await runtime.open(root, (id) => { if (executionError) throw new Error("Controlled execution failure"); executions.push(id); }), ); await page.addInitScript(() => { Object.defineProperty(navigator, "clipboard", { value: { writeText: async (value: string) => { if (sessionStorage.getItem("fixture-clipboard-denied")) throw new Error("Controlled clipboard denial"); sessionStorage.setItem("fixture-clipboard", value); }, }, }); }); await page.goto(url); const plan = page.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); const bundle = plan.locator(":scope > .board-row > .board-bundle"); await expect(page.locator("body")).toHaveAttribute("data-live-ready", "true"); const boardBefore = readFileSync( path.join(root, ".system/board.json"), "utf8", ); await bundle.locator(":scope > summary").click(); await expect(bundle).toHaveAttribute("open", ""); expect(readFileSync(path.join(root, ".system/board.json"), "utf8")).toBe( boardBefore, ); expect(executions).toEqual([]); await plan .getByRole("button", { name: "Copy PX-PLAN-PLAN0001", exact: true }) .click(); await expect(bundle).toHaveAttribute("open", ""); expect( await page.evaluate(() => sessionStorage.getItem("fixture-clipboard")), ).toBe("PX-PLAN-PLAN0001"); await page.evaluate(() => sessionStorage.setItem("fixture-clipboard-denied", "true"), ); await plan .getByRole("button", { name: "Copy PX-PLAN-PLAN0001", exact: true }) .click(); await expect(page.locator("[data-board-notice]")).toContainText( "Controlled clipboard denial", ); await expect(bundle).toHaveAttribute("open", ""); await plan.locator("[data-exec]").click(); await expect(page.locator("[data-board-notice]")).toContainText( "Exec requested", ); expect(executions).toEqual(["PX-PLAN-PLAN0001"]); executionError = true; expectHealth(page, "/api/exec:400"); await plan.locator("[data-exec]").click(); await expect(page.locator("[data-board-notice]")).toContainText( "Controlled execution failure", ); await expect(plan.locator("[data-exec]")).toBeEnabled(); // Real server/editor dispatch, but isolated node process rather than user's editor. const editorScript = path.join(root, "editor.mjs"); const editorLog = path.join(root, "edited.txt"); writeFileSync( editorScript, `import { writeFileSync } from 'node:fs'; writeFileSync(${JSON.stringify(editorLog)}, process.argv[2]);`, ); const previousVisual = process.env["VISUAL"]; process.env["VISUAL"] = `${JSON.stringify(process.execPath)} ${JSON.stringify(editorScript)}`; try { await plan.locator("[data-edit]").click(); await expect(page.locator("[data-board-notice]")).toContainText( "Document opened in editor", ); expect(readFileSync(editorLog, "utf8")).toBe( path.join(root, ".system/plans/PX-PLAN-PLAN0001-build/index.md"), ); } finally { if (previousVisual === undefined) delete process.env["VISUAL"]; else process.env["VISUAL"] = previousVisual; } // Negative UI contract only; never fall through to native editor fallbacks. expectHealth(page, "/api/edit:400"); await page.route("**/api/edit", (route) => route.fulfill({ status: 400, contentType: "application/json", body: JSON.stringify({ error: "Cannot open editor: controlled fixture" }), }), ); await plan.locator("[data-edit]").click(); await expect(page.locator("[data-board-notice]")).toContainText( "Cannot open editor", ); await expect(plan.locator("[data-edit]")).toBeEnabled(); await page.unroute("**/api/edit"); await runtime.tool.execute( "proposal", { items: [ { id: "PX-ISSUE-ISSUE001", state: "done", rationale: "Live verified proposal", }, ], }, new AbortController().signal, undefined, { cwd: root } as never, ); const issue = page.locator('[data-board-item][data-id="PX-ISSUE-ISSUE001"]'); await expect(issue.locator("[data-proposal]")).toContainText( "Live verified proposal", { timeout: 15000 }, ); await expect(bundle).toHaveAttribute("open", ""); // Replace proposal after display, then click stale button before next poll. await runtime.tool.execute( "proposal", { items: [] }, new AbortController().signal, undefined, { cwd: root } as never, ); expectHealth(page, "/api/proposal:400"); await issue.locator("[data-apply-proposal]").click(); await expect(page.locator("[data-board-notice]")).toContainText( "No matching assessment proposal", ); await expect(issue).not.toHaveClass(/is-done/); await expect(issue.locator("[data-proposal]")).toHaveCount(0, { timeout: 15000, }); }); test("commands share authenticated server, isolate cookies, reject cross-origin, and reopen after shutdown", async ({ page, playwright, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); runtimes.push(runtime); const notices: string[] = []; const command = createSystemCommand({ sendUserMessage() {} } as never, { openBook: (cwd, destination) => runtime.open(cwd, undefined, destination), }); for (const args of [ "book", "board", "view PX-SPEC-SPEC0001", "view contract", "view .system/specs/PX-SPEC-SPEC0001-contract/index.md", ]) await command.handler(args, ctx(root, notices)); const urls = notices.map(urlFromNotice); expect(new Set(urls.map((url) => new URL(url).origin)).size).toBe(1); const url = urls[0] ?? ""; const origin = new URL(url).origin; const anonymous = await playwright.request.newContext(); try { expect((await anonymous.get(`${origin}/`)).status()).toBe(403); const handshake = await anonymous.get(url, { maxRedirects: 0 }); expect(handshake.status()).toBe(303); expect(handshake.headers()["set-cookie"]).toContain( "HttpOnly; SameSite=Strict", ); expect(handshake.headers()["location"]).toBe("/"); expect((await anonymous.get(`${origin}/`)).ok()).toBe(true); const cross = await anonymous.post(`${origin}/api/state`, { headers: { origin: "https://attacker.invalid" }, data: { id: "PX-PLAN-PLAN0001", state: "done" }, }); expect(cross.status()).toBe(403); expect(await cross.json()).toEqual({ error: "Invalid board origin" }); const other = createBoardRuntime(); runtimes.push(other); const otherUrl = urlFromNotice(await other.open(systemFixture())); expect( (await anonymous.get(new URL("/api/state", otherUrl).href)).status(), ).toBe(403); for (const view of urls.slice(2)) { await page.goto(view); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); await expect(page.locator("#PX-SPEC-SPEC0001")).toBeInViewport(); } await page.close(); runtime.shutdown(); await expect( anonymous.get(`${origin}/api/state`, { timeout: 2000 }), ).rejects.toThrow(); const reopened = urlFromNotice(await runtime.open(root)); expect(new URL(reopened).searchParams.get("k")).not.toBe( new URL(url).searchParams.get("k"), ); expect( (await anonymous.get(new URL("/api/state", reopened).href)).status(), ).toBe(403); expect((await anonymous.get(reopened)).ok()).toBe(true); } finally { await anonymous.dispose(); } }); test("multiple tabs follow live state and recover malformed board while preserving reading context", async ({ page, context, }) => { const root = systemFixture(); const runtime = createBoardRuntime(); runtimes.push(runtime); const url = urlFromNotice( await runtime.open(root, undefined, "/#PX-SPEC-SPEC0001"), ); await page.goto(url); const second = await context.newPage(); observeHealth(second); await second.goto(new URL("/board.html", url).href); const ledger = page.locator("#PX-SPEC-SPEC0001 .ledger"); await ledger.locator(":scope > summary").click(); await page.locator("#search").fill("body-only-term"); const plan = second.locator('[data-board-item][data-id="PX-PLAN-PLAN0001"]'); await plan.locator(".board-state").click(); await second .locator('[data-board-item][data-id="PX-PLAN-PLAN0002"] .board-state') .click(); await second .locator( '[data-board-item][data-id="PX-SPEC-SPEC0001"] > .board-row > .board-actions > .board-state', ) .click(); await expect( page.locator("#PX-SPEC-SPEC0001 [data-board-toggle]"), ).toHaveText("done", { timeout: 15000 }); await expect(ledger).toHaveAttribute("open", ""); await expect(page.locator("#results")).toContainText("body-only-term"); const board = readFileSync(path.join(root, ".system/board.json"), "utf8"); write(root, ".system/board.json", "{"); await expect(page.locator("[data-board-notice]")).toContainText( "Invalid board JSON", { timeout: 15000 }, ); await expect(second.locator("[data-board-notice]")).toContainText( "Invalid board JSON", { timeout: 15000 }, ); const preview = new URL( "/.system/specs/PX-SPEC-SPEC0001-contract/mockup-card.html", url, ).href; expect(await (await page.request.get(preview)).text()).toContain( "Mockup card", ); await expect(plan).toHaveClass(/is-done/); write(root, ".system/board.json", board); const spec = ".system/specs/PX-SPEC-SPEC0001-contract/index.md"; const goodSource = readFileSync(path.join(root, spec), "utf8"); const malformed = ".system/issues/PX-ISSUE-ISSUE002-broken/index.md"; write(root, malformed, "---\nid: [\n---\n"); await expect(page.locator("#diagnostics")).toContainText(malformed, { timeout: 15000, }); expect(await (await page.request.get(preview)).text()).toContain( "Mockup card", ); await expect(page.locator("#PX-SPEC-SPEC0001")).toBeVisible(); write( root, malformed, "---\nid: PX-ISSUE-ISSUE002\ntype: issue\ntitle: Repaired\nspecs: [PX-SPEC-SPEC0001]\n---\n\n# Repaired\n", ); write(root, spec, goodSource + "\n\nRecovered across tabs.\n"); await expect( page.getByText("Recovered across tabs.", { exact: true }), ).toBeVisible({ timeout: 15000 }); await expect(ledger).toHaveAttribute("open", ""); await expect(page.locator("#search")).toHaveValue("body-only-term"); await expect(page.locator("#results")).toContainText("body-only-term"); await expect(page).toHaveURL(/#PX-SPEC-SPEC0001$/); await plan.locator(":scope > .board-row > .board-bundle > summary").click(); await expect(plan.getByText("Build", { exact: true }).first()).toBeVisible(); expectHealth(second, "/api/exec:failed"); await second.route("**/api/exec", (route) => route.abort("failed")); await plan.locator(".board-state").click(); await expect(plan.locator("[data-exec]")).toBeEnabled(); await plan.locator("[data-exec]").click(); await expect(second.locator("[data-board-notice]")).toContainText( "Reopen it with /system board", ); await expect(plan.locator("[data-exec]")).toBeEnabled(); await second.close(); }); function expectHealth(page: Page, key: string, count = 1): void { const state = health.get(page); if (!state) throw new Error("Health observer is not attached"); state.expected.set(key, (state.expected.get(key) ?? 0) + count); } function expectPageError(page: Page, pattern: RegExp): void { const state = health.get(page); if (!state) throw new Error("Health observer is not attached"); state.expectedPageErrors.push(pattern); } function consumeExpected( state: NonNullable>, key: string, ): boolean { const remaining = state.expected.get(key) ?? 0; if (!remaining) return false; state.expected.set(key, remaining - 1); return true; } function moduleDependencies(source: string): string[] { const parsed = parseSync("browser.js", source); expect(parsed.errors).toEqual([]); const module = parsed.module; return [ ...module.staticImports.map((item) => item.moduleRequest.value), ...module.staticExports.flatMap((item) => item.entries.flatMap((entry) => entry.moduleRequest ? [entry.moduleRequest.value] : [], ), ), ...module.dynamicImports.map((item) => { const expression = source.slice( item.moduleRequest.start, item.moduleRequest.end, ); const literal = /^["'`]([\w./-]+)["'`]$/.exec(expression); expect(literal, expression).not.toBeNull(); return literal?.[1] ?? ""; }), ]; } async function expectUnoccludedByBookHeader(page: Page, selector: string) { await expect .poll(() => page.locator(selector).evaluate((heading) => { const header = document.querySelector(".book-top"); return !header || getComputedStyle(header).position !== "fixed" ? true : heading.getBoundingClientRect().top >= header.getBoundingClientRect().bottom; }), ) .toBe(true); } async function assertSidebarConnected(page: Page) { await expect(page.locator(".book-nav")).toBeVisible(); await expect(page.locator(".book-nav")).toBeInViewport(); const layout = await page.evaluate(() => { const top = document.querySelector(".book-top")?.getBoundingClientRect(); const nav = document.querySelector(".book-nav")?.getBoundingClientRect(); const main = document.querySelector(".book-main")?.getBoundingClientRect(); return { scrollX, top: top ? { bottom: top.bottom, left: top.left, right: top.right } : null, nav: nav ? { top: nav.top, left: nav.left, right: nav.right } : null, main: main ? { left: main.left } : null, }; }); expect(layout.scrollX).toBe(0); expect(layout.top?.left).toBe(0); expect(layout.nav?.top).toBe(layout.top?.bottom); expect(layout.nav?.left).toBeGreaterThanOrEqual(0); expect(layout.nav?.right ?? 0).toBeLessThan(layout.main?.left ?? 0); } function ctx(root: string, notices: string[]) { return { cwd: root, waitForIdle: async () => {}, ui: { notify: (message: string) => notices.push(message) }, } as never; } function systemFixture(): string { const root = mkdtempSync(path.join(tmpdir(), "the-system-render-e2e-")); roots.push(root); for (const directory of ["specs", "phases", "plans", "issues", "research"]) mkdirSync(path.join(root, ".system", directory), { recursive: true }); write( root, ".system/config.json", '{"prefix":"PX","schemaVersion":0,"currentPhase":"PX-PHASE-PHASE002"}', ); write(root, ".system/board.json", '{"schemaVersion":0,"items":{}}'); write(root, ".system/SYSTEM.md", "# SYSTEM\n"); write(root, ".system/MISSION.md", "# MISSION\n"); write(root, ".system/RULES.md", "# RULES\n"); write( root, ".system/research/PX-RESEARCH-RSCH0001-notes/index.md", "---\nid: PX-RESEARCH-RSCH0001\ntype: research\ntitle: Notes\n---\n\n# Notes\n", ); write( root, ".system/specs/PX-SPEC-SPEC0001-contract/index.md", [ "---", "id: PX-SPEC-SPEC0001", "type: spec", "title: Contract", "research: [PX-RESEARCH-RSCH0001]", "---", "", "# Contract", "", "body-only-term", "", "```mermaid", "flowchart TD; A-->B;", "```", "", "$x+1$", "", "[Mockup](./mockup-card.html)", "", "

raw html works

", ].join("\n"), ); write( root, ".system/specs/PX-SPEC-SPEC0001-contract/mockup-card.html", "
Mockup card
", ); write( root, ".system/phases/PX-PHASE-PHASE001-delivery/index.md", "---\nid: PX-PHASE-PHASE001\ntype: phase\ntitle: Prototype\nlabel: prototype\n---\n\n# Prototype\n", ); write( root, ".system/phases/PX-PHASE-PHASE002-after-delivery/index.md", "---\nid: PX-PHASE-PHASE002\ntype: phase\ntitle: Pre-v1\nlabel: pre-v1\n---\n\n# Pre-v1\n", ); write( root, ".system/plans/PX-PLAN-PLAN0001-build/index.md", "---\nid: PX-PLAN-PLAN0001\ntype: plan\ntitle: Build\nspec: PX-SPEC-SPEC0001\nstatus: draft\n---\n\n# Build\n", ); write( root, ".system/plans/PX-PLAN-PLAN0002-test/index.md", "---\nid: PX-PLAN-PLAN0002\ntype: plan\ntitle: Test\nspec: PX-SPEC-SPEC0001\nstatus: draft\ndepends_on: [PX-PLAN-PLAN0001]\n---\n\n# Test\n", ); write( root, ".system/issues/PX-ISSUE-ISSUE001-bug/index.md", "---\nid: PX-ISSUE-ISSUE001\ntype: issue\ntitle: Bug\nspecs: [PX-SPEC-SPEC0001]\n---\n\n# Bug\n", ); return root; } function write(root: string, relative: string, content: string) { const target = path.join(root, relative); mkdirSync(path.dirname(target), { recursive: true }); writeFileSync(target, content, "utf8"); } function urlFromNotice(notice: string): string { const match = notice.match(/(?:opened|running): (http:\/\/\S+)$/m); expect(match?.[1]).toBeTruthy(); return match?.[1] ?? ""; } function hashTree(root: string): string { const hash = createHash("sha256"); for (const file of files(root).sort()) { hash.update(path.relative(root, file)); hash.update(readFileSync(file)); } return hash.digest("hex"); } function files(root: string): string[] { return readdirSync(root).flatMap((name) => { const file = path.join(root, name); return statSync(file).isDirectory() ? files(file) : [file]; }); }