@vmz/test 0.0.4 → 0.1.1

package/dist/browser.js

@@ -1,11 +1,14 @@
 /**
- * Browser Host for `vmz test --mode browser` ( close slice).
+ * Browser Host for `vmz test --mode browser` (U0–U2 thin).
  *
  * Real Chromium/Chrome via CDP. Transport may use puppeteer-core as a CDP
  * client — that is NOT the Playwright/Puppeteer *test model*. Manifest actions
- * and assertions remain the VMZ Browser Host protocol; same Direct schedule as
- * production (`__vmzCreate` in a real document).
+ * and assertions remain the VMZ Browser Host protocol.
  *
+ * U0: Locator / Action / Expectation dispatcher (browser-protocol.ts).
+ * U1: role/label/text/testId; click/fill/press/select; actionability + auto-wait.
+ * U2: real serve-host + RouteId open/navigate; console/request fail gate;
+ *     wall-clock timing + failure screenshot/DOM (not full U3 artifact pack).
  */
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
@@ -14,6 +17,9 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import { resolveChunkArtifacts } from './compile.js';
+import { createArtifactsDir, writeFailureEvidence, writeTimingOnly } from './browser-evidence.js';
+import { isServeHostManifest, resolveRoutePath, startServeHost } from './browser-serve.js';
+import { defaultClickLocator, parseActionLocator, resolveLocatorInPage, sleep, } from './browser-protocol.js';
 const MIME = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'text/javascript; charset=utf-8',
@@ -170,13 +176,24 @@ export async function runBrowserManifest(manifest, ctx) {
     const program = manifest.program && typeof manifest.program === 'object' ? manifest.program : {};
     const chunkId = String(program.chunkId || '');
     const programId = chunkId || null;
+    const useServe = isServeHostManifest(manifest);
+    const testId = String(manifest.id || 'anonymous');
+    const profile = manifest.profile && typeof manifest.profile === 'object' ? manifest.profile : {};
+    const failOnConsoleError = profile.failOnConsoleError !== false && (useServe || profile.failOnConsoleError === true);
+    const failOnRequestFailed = profile.failOnRequestFailed !== false && (useServe || profile.failOnRequestFailed === true);
     if (!chunkId) {
         fail('program.chunkId missing');
         return { status: 'error', diagnostics, planId: null, programId: null };
     }
-    const arts = resolveChunkArtifacts(ctx.outDir, chunkId);
-    if (!arts.clientPath) {
-        fail(`missing ${chunkId}.client.js`);
+    if (!useServe) {
+        const arts = resolveChunkArtifacts(ctx.outDir, chunkId);
+        if (!arts.clientPath) {
+            fail(`missing ${chunkId}.client.js`);
+            return { status: 'failed', diagnostics, planId: null, programId };
+        }
+    }
+    else if (!fs.existsSync(path.join(ctx.outDir, 'vmz-serve-host.mjs'))) {
+        fail(`serve host: missing vmz-serve-host.mjs under ${ctx.outDir}`);
         return { status: 'failed', diagnostics, planId: null, programId };
     }
     const chrome = findChromeExecutable();
@@ -185,13 +202,30 @@ export async function runBrowserManifest(manifest, ctx) {
         return { status: 'error', diagnostics, planId: null, programId };
     }
     let server = null;
+    let serveHost = null;
     let browser = null;
     let profileDir = null;
     let chromeChild = null;
+    let page = null;
+    const stepTimings = [];
+    const runStarted = Date.now();
+    const consoleErrors = [];
+    const failedRequests = [];
+    const artifactsDir = createArtifactsDir(ctx.outDir, testId);
+    const recordStep = (phase, kind, started, ok, detail) => {
+        stepTimings.push({ phase, kind, ms: Date.now() - started, ok, detail });
+    };
     try {
         const puppeteer = await loadPuppeteerCore();
-        server = await startStaticServer(ctx.outDir);
-        const origin = `http://127.0.0.1:${server.port}`;
+        let origin;
+        if (useServe) {
+            serveHost = await startServeHost(ctx.outDir);
+            origin = serveHost.origin;
+        }
+        else {
+            server = await startStaticServer(ctx.outDir);
+            origin = `http://127.0.0.1:${server.port}`;
+        }
         // CI: spawn+connect first (puppeteer.launch often "Connection closed" on Chrome for Testing).
         const ci = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
         const commonArgs = [
@@ -267,56 +301,108 @@ export async function runBrowserManifest(manifest, ctx) {
         if (!browser) {
             throw lastLaunchErr instanceof Error ? lastLaunchErr : new Error(`browser launch failed: ${String(lastLaunchErr)}`);
         }
-        const page = await browser.newPage();
+        page = await browser.newPage();
         page.setDefaultTimeout(15000);
-        await page.goto(`${origin}/__vmz/harness`, { waitUntil: 'domcontentloaded' });
-        const components = program.components && typeof program.components === 'object' ? program.components : {};
-        const boot = await page.evaluate(async (cfg) => {
-            const dom = await import(/* @vite-ignore */ `${cfg.origin}/vmz-dom.js`);
-            const Comp = (await import(/* @vite-ignore */ `${cfg.origin}/${cfg.chunkPath}.client.js`)).default;
-            const map = {};
-            for (const [name, chunk] of Object.entries(cfg.components)) {
-                map[name] = (await import(/* @vite-ignore */ `${cfg.origin}/${chunk}.client.js`)).default;
-            }
-            if (Object.keys(map).length && typeof dom.registerComponents === 'function') {
-                dom.registerComponents(map);
-            }
-            const app = document.getElementById('app');
-            if (!app)
-                return { ok: false, error: '#app missing' };
-            if (!Comp?.__vmzDirect || typeof Comp.__vmzCreate !== 'function') {
-                return { ok: false, error: 'Direct __vmzCreate required' };
-            }
-            window.__vmzBrowser = {
-                dom,
-                Comp,
-                app,
-                inst: null,
-                buttonBefore: null,
-                capturedChild: null,
-                lastPrecision: null,
-            };
-            return { ok: true };
-        }, {
-            origin,
-            chunkPath: chunkId.replace(/\\/g, '/'),
-            components,
+        page.on('console', (msg) => {
+            if (msg.type() === 'error')
+                consoleErrors.push(msg.text());
         });
-        if (!boot?.ok) {
-            fail(`browser boot: ${boot?.error || 'unknown'}`);
-            return {
-                status: 'error',
-                diagnostics,
-                planId: null,
-                programId,
-            };
+        page.on('pageerror', (err) => {
+            consoleErrors.push(err instanceof Error ? err.message : String(err));
+        });
+        page.on('requestfailed', (req) => {
+            const url = req.url();
+            const rt = typeof req.resourceType === 'function' ? req.resourceType() : '';
+            if (url.includes('favicon') || rt === 'image' || rt === 'media' || rt === 'font')
+                return;
+            const why = req.failure()?.errorText || 'failed';
+            // SPA client nav often aborts in-flight document; ignore benign aborts.
+            if (why.includes('ERR_ABORTED') || why.includes('net::ERR_ABORTED'))
+                return;
+            failedRequests.push(`${url} (${why})`);
+        });
+        if (useServe) {
+            page.__vmzServeOrigin = origin;
+            page.__vmzServeMode = true;
+        }
+        else {
+            await page.goto(`${origin}/__vmz/harness`, { waitUntil: 'domcontentloaded' });
+            const components = program.components && typeof program.components === 'object' ? program.components : {};
+            const boot = await page.evaluate(async (cfg) => {
+                const dom = await import(/* @vite-ignore */ `${cfg.origin}/vmz-dom.js`);
+                const Comp = (await import(/* @vite-ignore */ `${cfg.origin}/${cfg.chunkPath}.client.js`)).default;
+                const map = {};
+                for (const [name, chunk] of Object.entries(cfg.components)) {
+                    map[name] = (await import(/* @vite-ignore */ `${cfg.origin}/${chunk}.client.js`)).default;
+                }
+                if (Object.keys(map).length && typeof dom.registerComponents === 'function') {
+                    dom.registerComponents(map);
+                }
+                const app = document.getElementById('app');
+                if (!app)
+                    return { ok: false, error: '#app missing' };
+                if (!Comp?.__vmzDirect || typeof Comp.__vmzCreate !== 'function') {
+                    return { ok: false, error: 'Direct __vmzCreate required' };
+                }
+                window.__vmzBrowser = {
+                    dom,
+                    Comp,
+                    app,
+                    inst: null,
+                    buttonBefore: null,
+                    capturedChild: null,
+                    lastPrecision: null,
+                };
+                return { ok: true };
+            }, {
+                origin,
+                chunkPath: chunkId.replace(/\\/g, '/'),
+                components,
+            });
+            if (!boot?.ok) {
+                fail(`browser boot: ${boot?.error || 'unknown'}`);
+                return {
+                    status: 'error',
+                    diagnostics,
+                    planId: null,
+                    programId,
+                };
+            }
         }
         const actions = Array.isArray(manifest.actions) ? manifest.actions : [];
         for (const raw of actions) {
             const a = raw && typeof raw === 'object' ? raw : {};
             const kind = String(a.kind || '');
+            const started = Date.now();
+            let stepOk = true;
             try {
+                if (kind === 'open' || kind === 'navigate') {
+                    const pathname = resolveRoutePath(ctx.outDir, {
+                        routeId: a.routeId != null ? String(a.routeId) : undefined,
+                        path: a.path != null ? String(a.path) : undefined,
+                        params: a.params && typeof a.params === 'object'
+                            ? Object.fromEntries(Object.entries(a.params).map(([k, v]) => [k, String(v)]))
+                            : undefined,
+                    });
+                    const url = new URL(pathname, origin).toString();
+                    await page.goto(url, { waitUntil: 'domcontentloaded' });
+                    const timeoutMs = Number(a.timeoutMs) > 0 ? Number(a.timeoutMs) : 8000;
+                    const deadline = Date.now() + timeoutMs;
+                    while (Date.now() <= deadline) {
+                        const loc = await page.evaluate(() => ({
+                            path: location.pathname,
+                            ready: document.readyState,
+                        }));
+                        if (loc.path === pathname.split('?')[0] || loc.path.endsWith(pathname.split('?')[0]))
+                            break;
+                        await sleep(40);
+                    }
+                    recordStep('action', kind, started, true, pathname);
+                    continue;
+                }
                 if (kind === 'mount') {
+                    if (useServe)
+                        throw new Error('mount is for Direct harness only (not serve-host)');
                     const props = a.props && typeof a.props === 'object' ? a.props : {};
                     const r = await page.evaluate(async (p) => {
                         const ctx = window.__vmzBrowser;
@@ -333,21 +419,35 @@ export async function runBrowserManifest(manifest, ctx) {
                     }, props);
                     if (r.createHits !== 1)
                         fail(`mount must call __vmzCreate once, got ${r.createHits}`);
+                    recordStep('action', kind, started, true);
                     continue;
                 }
-                if (kind === 'click') {
-                    const selector = typeof a.selector === 'string' ? a.selector : 'button';
-                    // Real browser input path: Element.click in page (not linkedom).
-                    const ok = await page.evaluate((sel) => {
-                        const ctx = window.__vmzBrowser;
-                        const el = ctx.app.querySelector(sel);
-                        if (!el)
-                            return false;
-                        el.click();
-                        return true;
-                    }, selector);
-                    if (!ok)
-                        fail(`click: no element for ${JSON.stringify(selector)}`);
+                if (kind === 'click' || kind === 'fill' || kind === 'press' || kind === 'select') {
+                    const parsed = parseActionLocator(a);
+                    for (const w of parsed.warnings) {
+                        diagnostics.push({ severity: 'warning', message: w });
+                    }
+                    let locator = parsed.locator;
+                    if (!locator && kind === 'click')
+                        locator = defaultClickLocator();
+                    if (!locator) {
+                        fail(`${kind}: locator or legacy selector required`);
+                        stepOk = false;
+                        recordStep('action', kind, started, false);
+                        continue;
+                    }
+                    const timeoutMs = Number(a.timeoutMs) > 0 ? Number(a.timeoutMs) : 8000;
+                    const force = a.force === true;
+                    await waitForLocator(page, locator, { timeoutMs, force });
+                    if (kind === 'click')
+                        await clickTarget(page);
+                    else if (kind === 'fill')
+                        await fillTarget(page, a.value);
+                    else if (kind === 'press')
+                        await pressTarget(page, a.key ?? a.value ?? 'Enter');
+                    else
+                        await selectTarget(page, a.value ?? a.option, { timeoutMs, force });
+                    recordStep('action', kind, started, true);
                     continue;
                 }
                 if (kind === 'write') {
@@ -358,6 +458,7 @@ export async function runBrowserManifest(manifest, ctx) {
                             throw new Error('write before mount');
                         ctx.inst[args.field] = args.value;
                     }, { field, value: a.value });
+                    recordStep('action', kind, started, true);
                     continue;
                 }
                 if (kind === 'flush') {
@@ -367,6 +468,7 @@ export async function runBrowserManifest(manifest, ctx) {
                             throw new Error('flush before mount');
                         await ctx.dom.flushPending(ctx.inst);
                     });
+                    recordStep('action', kind, started, true);
                     continue;
                 }
                 if (kind === 'destroy') {
@@ -376,6 +478,7 @@ export async function runBrowserManifest(manifest, ctx) {
                             throw new Error('destroy before mount');
                         ctx.dom.destroy(ctx.inst);
                     });
+                    recordStep('action', kind, started, true);
                     continue;
                 }
                 if (kind === 'capture_child') {
@@ -390,6 +493,7 @@ export async function runBrowserManifest(manifest, ctx) {
                     }, selector);
                     if (!ok)
                         fail(`capture_child: no inst for ${JSON.stringify(selector)}`);
+                    recordStep('action', kind, started, ok);
                     continue;
                 }
                 if (kind === 'precision_reset') {
@@ -400,142 +504,371 @@ export async function runBrowserManifest(manifest, ctx) {
                         if (typeof ctx.dom.__vmzPrecisionReset === 'function')
                             ctx.dom.__vmzPrecisionReset();
                     });
+                    recordStep('action', kind, started, true);
                     continue;
                 }
                 fail(`unknown browser action ${JSON.stringify(kind)}`);
+                stepOk = false;
+                recordStep('action', kind, started, false);
             }
             catch (e) {
+                stepOk = false;
+                recordStep('action', kind, started, false, e instanceof Error ? e.message : String(e));
                 fail(`action ${kind}: ${e instanceof Error ? e.message : String(e)}`);
             }
+            void stepOk;
         }
         const assertions = Array.isArray(manifest.assertions) ? manifest.assertions : [];
         for (const raw of assertions) {
             const a = raw && typeof raw === 'object' ? raw : {};
             const kind = String(a.kind || '');
             const expect = a.expect && typeof a.expect === 'object' ? a.expect : {};
-            if (kind === 'text') {
-                const text = await page.evaluate(() => {
-                    const ctx = window.__vmzBrowser;
-                    return ctx.app.textContent || '';
-                });
-                if (expect.equals != null && text !== String(expect.equals)) {
-                    fail(`text equals want ${JSON.stringify(expect.equals)}, got ${JSON.stringify(text)}`);
-                }
-                if (expect.contains != null && !text.includes(String(expect.contains))) {
-                    fail(`text contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(text)}`);
-                }
-                continue;
-            }
-            if (kind === 'nodeIdentity') {
-                const sel = typeof expect.selector === 'string' ? expect.selector : 'button';
-                const same = await page.evaluate((s) => {
-                    const ctx = window.__vmzBrowser;
-                    const after = ctx.app.querySelector(s);
-                    return !!(ctx.buttonBefore && after && after === ctx.buttonBefore);
-                }, sel);
-                if (!same)
-                    fail(`nodeIdentity failed for ${sel} (real browser document)`);
-                continue;
-            }
-            if (kind === 'state') {
-                const state = await page.evaluate((keys) => {
-                    const ctx = window.__vmzBrowser;
-                    const out = {};
-                    for (const k of keys)
-                        out[k] = ctx.inst?.[k];
-                    return out;
-                }, Object.keys(expect));
-                for (const [k, v] of Object.entries(expect)) {
-                    if (state[k] !== v) {
-                        fail(`state.${k} want ${JSON.stringify(v)}, got ${JSON.stringify(state[k])}`);
+            const started = Date.now();
+            let stepOk = true;
+            try {
+                if (kind === 'text') {
+                    const timeoutMs = Number(a.timeoutMs ?? expect.timeoutMs) > 0 ? Number(a.timeoutMs ?? expect.timeoutMs) : 8000;
+                    const deadline = Date.now() + timeoutMs;
+                    let text = '';
+                    while (Date.now() <= deadline) {
+                        text = await pageText(page);
+                        if (expect.equals != null && text === String(expect.equals))
+                            break;
+                        if (expect.contains != null && text.includes(String(expect.contains)))
+                            break;
+                        if (expect.equals == null && expect.contains == null)
+                            break;
+                        await sleep(40);
+                    }
+                    if (expect.equals != null && text !== String(expect.equals)) {
+                        fail(`text equals want ${JSON.stringify(expect.equals)}, got ${JSON.stringify(text)}`);
+                        stepOk = false;
                     }
+                    if (expect.contains != null && !text.includes(String(expect.contains))) {
+                        fail(`text contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(text)}`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                continue;
-            }
-            if (kind === 'host') {
-                if (expect.kind === 'browser' || expect.realDocument === true) {
-                    const ok = await page.evaluate(() => typeof document !== 'undefined' && !!document.createElement);
-                    if (!ok)
-                        fail('host.realDocument failed');
+                if (kind === 'route') {
+                    const timeoutMs = Number(a.timeoutMs ?? expect.timeoutMs) > 0 ? Number(a.timeoutMs ?? expect.timeoutMs) : 8000;
+                    const deadline = Date.now() + timeoutMs;
+                    let loc = { path: '', href: '' };
+                    const wantPath = expect.path != null ? String(expect.path) : null;
+                    const wantContains = expect.pathContains != null ? String(expect.pathContains) : null;
+                    const wantRouteId = expect.routeId != null ? String(expect.routeId) : null;
+                    while (Date.now() <= deadline) {
+                        loc = await page.evaluate(() => ({ path: location.pathname, href: location.href }));
+                        let ok = true;
+                        if (wantPath != null && loc.path !== wantPath)
+                            ok = false;
+                        if (wantContains != null && !loc.path.includes(wantContains) && !loc.href.includes(wantContains))
+                            ok = false;
+                        if (wantRouteId != null) {
+                            const hit = await page.evaluate((id) => {
+                                const el = document.querySelector(`[data-vmz-route="${CSS.escape(id)}"]`);
+                                return !!el;
+                            }, wantRouteId);
+                            if (!hit && loc.path) {
+                                try {
+                                    const resolved = resolveRoutePath(ctx.outDir, { routeId: wantRouteId });
+                                    if (loc.path !== resolved && !loc.path.endsWith(resolved))
+                                        ok = false;
+                                    else
+                                        ok = true;
+                                }
+                                catch {
+                                    ok = hit;
+                                }
+                            }
+                            else if (!hit)
+                                ok = false;
+                        }
+                        if (ok)
+                            break;
+                        await sleep(40);
+                    }
+                    if (wantPath != null && loc.path !== wantPath) {
+                        fail(`route.path want ${wantPath}, got ${loc.path}`);
+                        stepOk = false;
+                    }
+                    if (wantContains != null && !loc.path.includes(wantContains) && !loc.href.includes(wantContains)) {
+                        fail(`route.pathContains want ${wantContains}, got ${loc.path}`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk, loc.path);
+                    continue;
                 }
-                continue;
-            }
-            if (kind === 'destroyed') {
-                const want = expect.value !== false;
-                const got = await page.evaluate(() => {
-                    const ctx = window.__vmzBrowser;
-                    return Boolean(ctx.inst?.__vmzDestroyed);
-                });
-                if (got !== want)
-                    fail(`__vmzDestroyed want ${want}, got ${got}`);
-                continue;
-            }
-            if (kind === 'childDestroyed') {
-                const want = expect.value !== false;
-                const got = await page.evaluate(() => {
-                    const ctx = window.__vmzBrowser;
-                    if (!ctx.capturedChild)
-                        return null;
-                    return Boolean(ctx.capturedChild.__vmzDestroyed);
-                });
-                if (got == null)
-                    fail('childDestroyed: no captured child (use capture_child action)');
-                else if (got !== want)
-                    fail(`child __vmzDestroyed want ${want}, got ${got}`);
-                continue;
-            }
-            if (kind === 'precision') {
-                const snap = await page.evaluate(() => {
-                    const ctx = window.__vmzBrowser;
-                    if (typeof ctx.dom.__vmzPrecisionSnapshot !== 'function')
-                        return null;
-                    return ctx.dom.__vmzPrecisionSnapshot();
-                });
-                if (!snap) {
-                    fail('precision snapshot unavailable');
+                if (kind === 'visible' || kind === 'count' || kind === 'value') {
+                    const fromAssert = parseActionLocator({
+                        locator: a.locator ?? expect.locator,
+                        selector: a.selector ?? expect.selector,
+                    });
+                    for (const w of fromAssert.warnings) {
+                        diagnostics.push({ severity: 'warning', message: w });
+                    }
+                    if (!fromAssert.locator) {
+                        fail(`${kind}: locator or legacy selector required`);
+                        recordStep('assertion', kind, started, false);
+                        continue;
+                    }
+                    const timeoutMs = Number(a.timeoutMs ?? expect.timeoutMs) > 0 ? Number(a.timeoutMs ?? expect.timeoutMs) : 8000;
+                    const deadline = Date.now() + timeoutMs;
+                    let last = {};
+                    while (Date.now() <= deadline) {
+                        last = await page.evaluate(resolveLocatorInPage, fromAssert.locator, { force: true });
+                        if (kind === 'visible') {
+                            if (Number(last?.count) >= 1)
+                                break;
+                        }
+                        else if (kind === 'count') {
+                            const want = Number(expect.equals ?? expect.count);
+                            if (Number.isFinite(want) && Number(last?.count) === want)
+                                break;
+                        }
+                        else if (kind === 'value') {
+                            if (last?.ok && last.count === 1) {
+                                const val = await page.evaluate(() => {
+                                    const el = document.querySelector('[data-vmz-bh-target="1"]');
+                                    return el ? String(el.value) : null;
+                                });
+                                last.value = val;
+                                if (expect.equals != null && val === String(expect.equals))
+                                    break;
+                                if (expect.contains != null && val != null && val.includes(String(expect.contains)))
+                                    break;
+                                if (expect.equals == null && expect.contains == null)
+                                    break;
+                            }
+                        }
+                        else
+                            break;
+                        await sleep(40);
+                    }
+                    if (kind === 'visible') {
+                        if (!(Number(last?.count) >= 1)) {
+                            fail(`visible: ${last?.reason || 'not found'} ${JSON.stringify(fromAssert.locator)}`);
+                            stepOk = false;
+                        }
+                    }
+                    else if (kind === 'count') {
+                        const want = Number(expect.equals ?? expect.count);
+                        if (!Number.isFinite(want) || Number(last?.count) !== want) {
+                            fail(`count want ${want}, got ${last?.count} (${last?.reason || ''})`);
+                            stepOk = false;
+                        }
+                    }
+                    else if (kind === 'value') {
+                        const val = last.value ??
+                            (await page.evaluate(() => {
+                                const el = document.querySelector('[data-vmz-bh-target="1"]');
+                                return el ? String(el.value) : null;
+                            }));
+                        if (expect.equals != null && val !== String(expect.equals)) {
+                            fail(`value equals want ${JSON.stringify(expect.equals)}, got ${JSON.stringify(val)}`);
+                            stepOk = false;
+                        }
+                        if (expect.contains != null && (val == null || !String(val).includes(String(expect.contains)))) {
+                            fail(`value contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(val)}`);
+                            stepOk = false;
+                        }
+                    }
+                    recordStep('assertion', kind, started, stepOk);
                     continue;
                 }
-                if (expect.minWrites != null && Number(snap.writes || 0) < Number(expect.minWrites)) {
-                    fail(`precision.writes want >= ${expect.minWrites}, got ${snap.writes}`);
+                if (kind === 'nodeIdentity') {
+                    const sel = typeof expect.selector === 'string' ? expect.selector : 'button';
+                    const same = await page.evaluate((s) => {
+                        const ctx = window.__vmzBrowser;
+                        const after = ctx.app.querySelector(s);
+                        return !!(ctx.buttonBefore && after && after === ctx.buttonBefore);
+                    }, sel);
+                    if (!same) {
+                        fail(`nodeIdentity failed for ${sel} (real browser document)`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.maxWrites != null && Number(snap.writes || 0) > Number(expect.maxWrites)) {
-                    fail(`precision.writes want <= ${expect.maxWrites}, got ${snap.writes}`);
+                if (kind === 'state') {
+                    const state = await page.evaluate((keys) => {
+                        const ctx = window.__vmzBrowser;
+                        const out = {};
+                        for (const k of keys)
+                            out[k] = ctx.inst?.[k];
+                        return out;
+                    }, Object.keys(expect));
+                    for (const [k, v] of Object.entries(expect)) {
+                        if (state[k] !== v) {
+                            fail(`state.${k} want ${JSON.stringify(v)}, got ${JSON.stringify(state[k])}`);
+                            stepOk = false;
+                        }
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.maxBindingEvals != null && Number(snap.bindingEvals || 0) > Number(expect.maxBindingEvals)) {
-                    fail(`precision.bindingEvals want <= ${expect.maxBindingEvals}, got ${snap.bindingEvals}`);
+                if (kind === 'host') {
+                    if (expect.kind === 'browser' || expect.realDocument === true) {
+                        const ok = await page.evaluate(() => typeof document !== 'undefined' && !!document.createElement);
+                        if (!ok) {
+                            fail('host.realDocument failed');
+                            stepOk = false;
+                        }
+                    }
+                    if (expect.serveHost === true && !useServe) {
+                        fail('host.serveHost expected but manifest used static harness');
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.maxPatchExecs != null && Number(snap.patchExecs || 0) > Number(expect.maxPatchExecs)) {
-                    fail(`precision.patchExecs want <= ${expect.maxPatchExecs}, got ${snap.patchExecs}`);
+                if (kind === 'destroyed') {
+                    const want = expect.value !== false;
+                    const got = await page.evaluate(() => {
+                        const ctx = window.__vmzBrowser;
+                        return Boolean(ctx.inst?.__vmzDestroyed);
+                    });
+                    if (got !== want) {
+                        fail(`__vmzDestroyed want ${want}, got ${got}`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.patchesIncludeDep != null) {
-                    const dep = String(expect.patchesIncludeDep);
-                    const map = snap.patchesByDep || {};
-                    if (!map[dep])
-                        fail(`precision.patchesByDep missing ${dep}: ${JSON.stringify(map)}`);
+                if (kind === 'childDestroyed') {
+                    const want = expect.value !== false;
+                    const got = await page.evaluate(() => {
+                        const ctx = window.__vmzBrowser;
+                        if (!ctx.capturedChild)
+                            return null;
+                        return Boolean(ctx.capturedChild.__vmzDestroyed);
+                    });
+                    if (got == null) {
+                        fail('childDestroyed: no captured child (use capture_child action)');
+                        stepOk = false;
+                    }
+                    else if (got !== want) {
+                        fail(`child __vmzDestroyed want ${want}, got ${got}`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.writesIncludeRoot != null) {
-                    const rootKey = String(expect.writesIncludeRoot);
-                    const map = snap.writesByRoot || {};
-                    if (!map[rootKey])
-                        fail(`precision.writesByRoot missing ${rootKey}: ${JSON.stringify(map)}`);
+                if (kind === 'precision') {
+                    const snap = await page.evaluate(() => {
+                        const ctx = window.__vmzBrowser;
+                        if (typeof ctx.dom.__vmzPrecisionSnapshot !== 'function')
+                            return null;
+                        return ctx.dom.__vmzPrecisionSnapshot();
+                    });
+                    if (!snap) {
+                        fail('precision snapshot unavailable');
+                        recordStep('assertion', kind, started, false);
+                        continue;
+                    }
+                    if (expect.minWrites != null && Number(snap.writes || 0) < Number(expect.minWrites)) {
+                        fail(`precision.writes want >= ${expect.minWrites}, got ${snap.writes}`);
+                        stepOk = false;
+                    }
+                    if (expect.maxWrites != null && Number(snap.writes || 0) > Number(expect.maxWrites)) {
+                        fail(`precision.writes want <= ${expect.maxWrites}, got ${snap.writes}`);
+                        stepOk = false;
+                    }
+                    if (expect.maxBindingEvals != null && Number(snap.bindingEvals || 0) > Number(expect.maxBindingEvals)) {
+                        fail(`precision.bindingEvals want <= ${expect.maxBindingEvals}, got ${snap.bindingEvals}`);
+                        stepOk = false;
+                    }
+                    if (expect.maxPatchExecs != null && Number(snap.patchExecs || 0) > Number(expect.maxPatchExecs)) {
+                        fail(`precision.patchExecs want <= ${expect.maxPatchExecs}, got ${snap.patchExecs}`);
+                        stepOk = false;
+                    }
+                    if (expect.patchesIncludeDep != null) {
+                        const dep = String(expect.patchesIncludeDep);
+                        const map = snap.patchesByDep || {};
+                        if (!map[dep]) {
+                            fail(`precision.patchesByDep missing ${dep}: ${JSON.stringify(map)}`);
+                            stepOk = false;
+                        }
+                    }
+                    if (expect.writesIncludeRoot != null) {
+                        const rootKey = String(expect.writesIncludeRoot);
+                        const map = snap.writesByRoot || {};
+                        if (!map[rootKey]) {
+                            fail(`precision.writesByRoot missing ${rootKey}: ${JSON.stringify(map)}`);
+                            stepOk = false;
+                        }
+                    }
+                    if (expect.domCreates === 0 || expect.domCreates === false) {
+                        if (Number(snap.domCreates || 0) !== 0) {
+                            fail(`precision.domCreates want 0 after action window, got ${snap.domCreates}`);
+                            stepOk = false;
+                        }
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
                 }
-                if (expect.domCreates === 0 || expect.domCreates === false) {
-                    if (Number(snap.domCreates || 0) !== 0) {
-                        fail(`precision.domCreates want 0 after action window, got ${snap.domCreates}`);
+                if (kind === 'timing') {
+                    // Presence of step timings is enough for thin evidence gate.
+                    if (!stepTimings.length) {
+                        fail('timing: no recorded steps');
+                        stepOk = false;
                     }
+                    if (expect.minSteps != null && stepTimings.length < Number(expect.minSteps)) {
+                        fail(`timing.minSteps want >= ${expect.minSteps}, got ${stepTimings.length}`);
+                        stepOk = false;
+                    }
+                    recordStep('assertion', kind, started, stepOk);
+                    continue;
+                }
+                if (kind === 'graph' || kind === 'plan' || kind === 'diagnostic' || kind === 'view' || kind === 'motion') {
+                    recordStep('assertion', kind, started, true);
+                    continue;
                 }
-                continue;
+                fail(`unknown browser assertion ${JSON.stringify(kind)}`);
+                recordStep('assertion', kind, started, false);
             }
-            if (kind === 'graph' || kind === 'plan' || kind === 'diagnostic' || kind === 'view' || kind === 'motion') {
-                continue;
+            catch (e) {
+                recordStep('assertion', kind, started, false, e instanceof Error ? e.message : String(e));
+                fail(`assertion ${kind}: ${e instanceof Error ? e.message : String(e)}`);
             }
-            fail(`unknown browser assertion ${JSON.stringify(kind)}`);
+        }
+        if (failOnConsoleError && consoleErrors.length) {
+            fail(`console errors (${consoleErrors.length}): ${consoleErrors.slice(0, 3).join(' | ')}`);
+        }
+        if (failOnRequestFailed && failedRequests.length) {
+            fail(`request failed (${failedRequests.length}): ${failedRequests.slice(0, 3).join(' | ')}`);
         }
     }
     catch (e) {
         fail(e instanceof Error ? e.message : String(e));
     }
     finally {
+        const timing = {
+            schema: 'vmz.test.browser.timing.v0',
+            totalMs: Date.now() - runStarted,
+            steps: stepTimings,
+        };
+        const failed = diagnostics.some((d) => d.severity === 'error');
+        try {
+            if (failed && page) {
+                const paths = await writeFailureEvidence(page, artifactsDir, timing);
+                diagnostics.push({
+                    severity: 'info',
+                    message: `browser evidence: ${paths.timing || ''}${paths.screenshot ? `; screenshot ${paths.screenshot}` : ''}`,
+                });
+            }
+            else {
+                const timingPath = writeTimingOnly(artifactsDir, timing);
+                diagnostics.push({ severity: 'info', message: `browser timing: ${timingPath}` });
+            }
+        }
+        catch (e) {
+            diagnostics.push({
+                severity: 'warning',
+                message: `evidence write failed: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
         try {
             if (browser) {
                 if (chromeChild)
@@ -569,6 +902,13 @@ export async function runBrowserManifest(manifest, ctx) {
         catch {
             /* ignore */
         }
+        try {
+            if (serveHost)
+                serveHost.kill();
+        }
+        catch {
+            /* ignore */
+        }
     }
     const failed = diagnostics.some((d) => d.severity === 'error');
     return {
@@ -582,3 +922,120 @@ export async function runBrowserManifest(manifest, ctx) {
 export function resolveBrowserExecutable() {
     return findChromeExecutable();
 }
+/**
+ * Auto-wait until locator resolves to exactly one actionable element.
+ */
+async function waitForLocator(page, locator, opts = {}) {
+    const timeoutMs = Number(opts.timeoutMs) > 0 ? Number(opts.timeoutMs) : 8000;
+    const force = opts.force === true;
+    const deadline = Date.now() + timeoutMs;
+    let last = {
+        ok: false,
+        count: 0,
+        actionable: false,
+        reason: 'not attempted',
+        index: -1,
+    };
+    while (Date.now() <= deadline) {
+        last = (await page.evaluate(resolveLocatorInPage, locator, { force }));
+        if (last && last.ok && last.actionable && last.count === 1)
+            return last;
+        await sleep(40);
+    }
+    throw new Error(`locator timeout (${timeoutMs}ms): ${last?.reason || 'unknown'} count=${last?.count ?? 0} ${JSON.stringify(locator)}`);
+}
+async function clickTarget(page) {
+    const ok = await page.evaluate(() => {
+        const el = document.querySelector('[data-vmz-bh-target="1"]');
+        if (!el)
+            return false;
+        el.focus();
+        el.click();
+        return true;
+    });
+    if (!ok)
+        throw new Error('click: resolved target missing in document');
+}
+async function fillTarget(page, value) {
+    const ok = await page.evaluate((v) => {
+        const el = document.querySelector('[data-vmz-bh-target="1"]');
+        if (!el)
+            return false;
+        el.focus();
+        const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+        const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+        if (setter)
+            setter.call(el, String(v));
+        else
+            el.value = String(v);
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        return true;
+    }, value);
+    if (!ok)
+        throw new Error('fill: resolved target missing or not an input');
+}
+async function pressTarget(page, key) {
+    const ok = await page.evaluate((k) => {
+        const el = document.querySelector('[data-vmz-bh-target="1"]') || document.activeElement;
+        if (!el)
+            return false;
+        el.dispatchEvent(new KeyboardEvent('keydown', { key: String(k), bubbles: true }));
+        el.dispatchEvent(new KeyboardEvent('keyup', { key: String(k), bubbles: true }));
+        return true;
+    }, key);
+    if (!ok)
+        throw new Error('press: no target/focused element');
+}
+async function pageText(page) {
+    return (await page.evaluate(() => {
+        const ctx = window.__vmzBrowser;
+        if (ctx?.app)
+            return ctx.app.textContent || '';
+        return document.body?.innerText || document.body?.textContent || '';
+    }));
+}
+/**
+ * Native <select> or listbox/combobox (data-vmz-option / role=option).
+ * Prefer option value (data-vmz-option) then accessible name/label.
+ */
+async function selectTarget(page, value, opts = {}) {
+    const want = String(value ?? '');
+    if (!want)
+        throw new Error('select: value/option required');
+    const native = await page.evaluate((v) => {
+        const el = document.querySelector('[data-vmz-bh-target="1"]');
+        if (!el)
+            return { ok: false, reason: 'missing target' };
+        if (el instanceof HTMLSelectElement) {
+            el.focus();
+            el.value = v;
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+            return { ok: true, kind: 'native' };
+        }
+        // Custom combobox/listbox: open if needed, then click option.
+        const expanded = el.getAttribute('aria-expanded');
+        if (expanded !== 'true')
+            el.click();
+        return { ok: true, kind: 'custom' };
+    }, want);
+    if (!native || !native.ok) {
+        throw new Error(`select: ${native?.reason || 'failed'}`);
+    }
+    if (native.kind === 'native')
+        return;
+    // Prefer stable option value contract, then accessible name.
+    const byValue = { kind: 'css', selector: `[data-vmz-option="${want.replace(/"/g, '\\"')}"]` };
+    try {
+        await waitForLocator(page, byValue, opts);
+        await clickTarget(page);
+        return;
+    }
+    catch {
+        /* fall through to role=option name */
+    }
+    const optionLocator = { kind: 'role', role: 'option', name: want };
+    await waitForLocator(page, optionLocator, opts);
+    await clickTarget(page);
+}