@vmz/test 0.0.0 → 0.0.2

package/dist/resume.js

@@ -0,0 +1,256 @@
+/**
+ * Resume host for `vmz test --mode resume` (T2/T3 first slice).
+ * SSR shell → resume adopt → event patch; onMount must not run.
+ */
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolveChunkArtifacts } from './compile.js';
+import { installHeadlessDocument } from './logic.js';
+export async function runResumeManifest(manifest, ctx) {
+    const diagnostics = [];
+    const program = manifest.program && typeof manifest.program === 'object' ? manifest.program : {};
+    const chunkId = String(program.chunkId || '');
+    const programId = chunkId || null;
+    const fail = (message, extra = {}) => {
+        diagnostics.push({ severity: 'error', message, ...extra });
+    };
+    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`);
+        return { status: 'failed', diagnostics, planId: null, programId };
+    }
+    installHeadlessDocument();
+    globalThis.requestIdleCallback = (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 1 }), 0);
+    let dom;
+    let Page;
+    try {
+        dom = await import(pathToFileURL(path.join(ctx.outDir, 'vmz-dom.js')).href);
+        Page = (await import(pathToFileURL(arts.clientPath).href)).default;
+    }
+    catch (e) {
+        fail(`import dist: ${e instanceof Error ? e.message : String(e)}`);
+        return { status: 'error', diagnostics, planId: null, programId };
+    }
+    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
+    const loaded = {};
+    if (components) {
+        for (const [name, chunk] of Object.entries(components)) {
+            const cArts = resolveChunkArtifacts(ctx.outDir, chunk);
+            if (!cArts.clientPath) {
+                fail(`missing component ${chunk}`);
+                continue;
+            }
+            loaded[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
+        }
+        dom.registerComponents(loaded);
+    }
+    let html = '';
+    let island = null;
+    let inst = null;
+    let buttonBefore = null;
+    let onMountHits = 0;
+    let createHits = 0;
+    const resumeTarget = String(program.resumeComponent || Object.keys(loaded)[0] || '');
+    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 || '');
+        try {
+            if (kind === 'ssr' || kind === 'renderToString') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                html = await dom.renderToString(Page, props);
+                continue;
+            }
+            if (kind === 'attachEventEntries') {
+                if (!html)
+                    html = await dom.renderToString(Page, {});
+                document.body.innerHTML = `<div id="app">${html}</div>`;
+                const islandName = String(a.component || resumeTarget);
+                island = document.querySelector(`[data-vmz-island="${islandName}"]`);
+                if (!island) {
+                    fail(`EventEntry host missing for ${islandName}`);
+                    continue;
+                }
+                buttonBefore = island.querySelector('button');
+                if (typeof dom.attachEventEntries !== 'function') {
+                    fail('attachEventEntries missing from vmz-dom');
+                    continue;
+                }
+                dom.attachEventEntries(document);
+                continue;
+            }
+            if (kind === 'resumeIslands') {
+                if (!html)
+                    html = await dom.renderToString(Page, {});
+                document.body.innerHTML = `<div id="app">${html}</div>`;
+                const islandName = String(a.component || resumeTarget);
+                island = document.querySelector(`[data-vmz-island="${islandName}"]`);
+                if (!island) {
+                    fail(`island host missing for ${islandName}`);
+                    continue;
+                }
+                buttonBefore = island.querySelector('button');
+                dom.resumeIslands(document);
+                continue;
+            }
+            if (kind === 'resume') {
+                if (!html)
+                    html = await dom.renderToString(Page, {});
+                document.body.innerHTML = `<div id="app">${html}</div>`;
+                const islandName = String(a.component || resumeTarget);
+                island = document.querySelector(`[data-vmz-island="${islandName}"]`);
+                if (!island) {
+                    fail(`island host missing for ${islandName}`);
+                    continue;
+                }
+                buttonBefore = island.querySelector('button');
+                const Comp = loaded[islandName];
+                if (!Comp) {
+                    fail(`resume component ${islandName} not registered`);
+                    continue;
+                }
+                const prevMount = Comp.prototype.onMount;
+                Comp.prototype.onMount = function () {
+                    onMountHits += 1;
+                    if (typeof prevMount === 'function')
+                        return prevMount.call(this);
+                };
+                const origCreate = Comp.__vmzCreate;
+                Comp.__vmzCreate = function (api) {
+                    createHits += 1;
+                    return origCreate.call(this, api);
+                };
+                inst = await dom.resume(Comp, island);
+                Comp.__vmzCreate = origCreate;
+                Comp.prototype.onMount = prevMount;
+                continue;
+            }
+            if (kind === 'clickHost' || kind === 'clickIsland') {
+                const sel = typeof a.selector === 'string' ? a.selector : `[data-vmz-island="${String(a.component || resumeTarget)}"]`;
+                const el = document.querySelector(sel);
+                if (!el) {
+                    fail(`clickHost: no ${sel}`);
+                    continue;
+                }
+                island = el;
+                el.click();
+                // EventEntry resume is async via Promise.resolve(fn()).
+                await Promise.resolve();
+                await Promise.resolve();
+                await new Promise((r) => setTimeout(r, Number(a.waitMs ?? 10)));
+                inst = el.__vmzInst || inst;
+                continue;
+            }
+            if (kind === 'click') {
+                const root = island || document.getElementById('app');
+                const sel = typeof a.selector === 'string' ? a.selector : 'button';
+                const el = root?.querySelector(sel);
+                if (!el) {
+                    fail(`click: no ${sel}`);
+                    continue;
+                }
+                el.click();
+                continue;
+            }
+            if (kind === 'flush') {
+                if (!inst) {
+                    fail('flush before resume');
+                    continue;
+                }
+                await dom.flushPending(inst);
+                continue;
+            }
+            if (kind === 'assert') {
+                const assertion = String(a.assertion || 'html');
+                const expect = a.expect && typeof a.expect === 'object' ? a.expect : {};
+                if (assertion === 'html') {
+                    if (expect.contains != null && !html.includes(String(expect.contains))) {
+                        fail(`html contains want ${JSON.stringify(expect.contains)}`);
+                    }
+                    if (expect.notContains != null && html.includes(String(expect.notContains))) {
+                        fail(`html notContains ${JSON.stringify(expect.notContains)}`);
+                    }
+                    continue;
+                }
+                if (assertion === 'resumed') {
+                    const want = expect.value !== false;
+                    const got = Boolean(island?.__vmzResumed);
+                    if (got !== want)
+                        fail(`__vmzResumed want ${want}, got ${got}`);
+                    continue;
+                }
+                fail(`unknown resume assert ${assertion}`);
+                continue;
+            }
+            fail(`unknown resume action ${JSON.stringify(kind)}`);
+        }
+        catch (e) {
+            fail(`action ${kind}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    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 === 'html') {
+            if (expect.contains != null && !html.includes(String(expect.contains))) {
+                fail(`html contains want ${JSON.stringify(expect.contains)}`);
+            }
+            continue;
+        }
+        if (kind === 'resumed') {
+            const want = expect.value !== false;
+            if (Boolean(island?.__vmzResumed) !== want) {
+                fail(`__vmzResumed want ${want}, got ${Boolean(island?.__vmzResumed)}`);
+            }
+            continue;
+        }
+        if (kind === 'onMount') {
+            const want = Number(expect.hits ?? 0);
+            if (onMountHits !== want)
+                fail(`onMount hits want ${want}, got ${onMountHits}`);
+            continue;
+        }
+        if (kind === 'createOnce') {
+            if (createHits !== 1)
+                fail(`__vmzCreate want 1, got ${createHits}`);
+            continue;
+        }
+        if (kind === 'nodeIdentity') {
+            const after = island?.querySelector('button') ?? null;
+            if (!buttonBefore || !after || after !== buttonBefore) {
+                fail('button node identity changed on resume');
+            }
+            continue;
+        }
+        if (kind === 'text') {
+            const text = island?.querySelector('button')?.textContent ?? island?.textContent ?? '';
+            if (expect.contains != null && !text.includes(String(expect.contains))) {
+                fail(`text contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(text)}`);
+            }
+            if (Array.isArray(expect.containsAny)) {
+                const ok = expect.containsAny.some((s) => text.includes(String(s)));
+                if (!ok) {
+                    fail(`text containsAny want ${JSON.stringify(expect.containsAny)}, got ${JSON.stringify(text)}`);
+                }
+            }
+            continue;
+        }
+        if (kind === 'graph' || kind === 'plan' || kind === 'deployment' || kind === 'diagnostic') {
+            continue;
+        }
+        fail(`unknown resume assertion ${JSON.stringify(kind)}`);
+    }
+    const failed = diagnostics.some((d) => d.severity === 'error');
+    return {
+        status: failed ? 'failed' : 'passed',
+        diagnostics,
+        planId: null,
+        programId,
+    };
+}

package/dist/run.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Programmatic entry: run manifests without CLI discovery automation.
+ */
+import { type BuildOptions, type CompileResult } from './compile.js';
+import { type LogicResult } from './logic.js';
+import { type TestMode } from './protocol.js';
+export type RunManifestOptions = BuildOptions & {
+    outDir?: string;
+    modes?: TestMode[];
+    /** When true, skip build and use existing outDir. */
+    reuseOutDir?: boolean;
+};
+export type ManifestRunResult = {
+    testId: string;
+    status: string;
+    diagnostics: unknown[];
+    programId: string | null;
+    planId: string | null;
+    compile?: CompileResult;
+    logic?: LogicResult;
+    outDir: string | null;
+};
+/** Run a single manifest object (no discovery). Caller supplies project root for build. */
+export declare function runManifest(manifest: Record<string, unknown>, projectRoot: string, options?: RunManifestOptions): Promise<ManifestRunResult>;
+/** Convenience: build report skeleton from runManifest results. */
+export declare function resultsToReport(project: string, modes: TestMode[], results: ManifestRunResult[], files?: Record<string, string>): {
+    schema: string;
+    status: string;
+    project: string;
+    modes: TestMode[];
+    generatedAt: string;
+    tests: {
+        testId: string;
+        file: string;
+        modes: string[];
+        programId: string | null;
+        planId: string | null;
+        status: string;
+        diagnostics: unknown[];
+        trace: null;
+        snapshots: null;
+        coverage: null;
+        unknownReasons: string[];
+    }[];
+};

package/dist/run.js

@@ -0,0 +1,97 @@
+/**
+ * Programmatic entry: run manifests without CLI discovery automation.
+ */
+import path from 'node:path';
+import { buildForCompile, runCompileManifest } from './compile.js';
+import { runLogicManifest } from './logic.js';
+import { buildTestReport } from './protocol.js';
+/** Run a single manifest object (no discovery). Caller supplies project root for build. */
+export async function runManifest(manifest, projectRoot, options = {}) {
+    const testId = String(manifest.id || 'anonymous');
+    const mModes = Array.isArray(manifest.modes) ? manifest.modes.map(String) : [];
+    const active = options.modes?.length ? options.modes : ['all'];
+    const modeActive = (name) => active.includes('all') || active.includes(name);
+    const doCompile = mModes.includes('compile') && modeActive('compile');
+    const doLogic = mModes.includes('logic') && modeActive('logic');
+    let outDir = options.outDir ?? null;
+    if ((doCompile || doLogic) && !options.reuseOutDir) {
+        const built = buildForCompile(projectRoot, options.outDir, options);
+        outDir = built.outDir;
+        if (!built.ok) {
+            return {
+                testId,
+                status: 'error',
+                diagnostics: [...built.diagnostics, { severity: 'error', message: built.error }],
+                programId: null,
+                planId: null,
+                outDir,
+            };
+        }
+    }
+    if (!outDir && (doCompile || doLogic)) {
+        return {
+            testId,
+            status: 'error',
+            diagnostics: [{ severity: 'error', message: 'outDir unavailable' }],
+            programId: null,
+            planId: null,
+            outDir: null,
+        };
+    }
+    const diags = [];
+    const statuses = [];
+    let programId = null;
+    let planId = null;
+    let compile;
+    let logic;
+    if (doCompile && outDir) {
+        compile = runCompileManifest(manifest, { outDir });
+        statuses.push(compile.status);
+        diags.push(...compile.diagnostics);
+        programId = compile.programId;
+        planId = compile.planId;
+    }
+    if (doLogic && outDir) {
+        logic = await runLogicManifest(manifest, { outDir });
+        statuses.push(logic.status);
+        diags.push(...logic.diagnostics);
+        programId = logic.programId ?? programId;
+        planId = logic.planId ?? planId;
+    }
+    let status = 'skipped';
+    if (statuses.includes('error'))
+        status = 'error';
+    else if (statuses.includes('failed'))
+        status = 'failed';
+    else if (statuses.length && statuses.every((s) => s === 'passed'))
+        status = 'passed';
+    else if (!doCompile && !doLogic)
+        status = 'skipped';
+    return {
+        testId,
+        status,
+        diagnostics: diags,
+        programId,
+        planId,
+        compile,
+        logic,
+        outDir,
+    };
+}
+/** Convenience: build report skeleton from runManifest results. */
+export function resultsToReport(project, modes, results, files = {}) {
+    return buildTestReport({
+        project: path.relative(process.cwd(), project) || '.',
+        modes,
+        tests: results.map((r) => ({
+            testId: r.testId,
+            file: files[r.testId] || '',
+            modes: [],
+            programId: r.programId,
+            planId: r.planId,
+            status: r.status,
+            diagnostics: r.diagnostics,
+        })),
+        status: results.some((r) => r.status === 'failed' || r.status === 'error') ? 'failed' : results.length ? 'passed' : 'empty',
+    });
+}

package/dist/ssr.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SSR / hydrate / stream host for `vmz test --mode ssr` (T2).
+ * Same Direct schedule as production via linkedom + renderToString / renderToStream / hydrate.
+ */
+type Diag = {
+    severity: string;
+    message: string;
+    [k: string]: unknown;
+};
+export type SsrResult = {
+    status: 'passed' | 'failed' | 'error';
+    diagnostics: Diag[];
+    planId: string | null;
+    programId: string | null;
+};
+export declare function runSsrManifest(manifest: Record<string, unknown>, ctx: {
+    outDir: string;
+}): Promise<SsrResult>;
+export {};

package/dist/ssr.js

@@ -0,0 +1,249 @@
+/**
+ * SSR / hydrate / stream host for `vmz test --mode ssr` (T2).
+ * Same Direct schedule as production via linkedom + renderToString / renderToStream / hydrate.
+ */
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolveChunkArtifacts } from './compile.js';
+import { installHeadlessDocument } from './logic.js';
+export async function runSsrManifest(manifest, ctx) {
+    const diagnostics = [];
+    const program = manifest.program && typeof manifest.program === 'object' ? manifest.program : {};
+    const chunkId = String(program.chunkId || '');
+    const programId = chunkId || null;
+    const fail = (message, extra = {}) => {
+        diagnostics.push({ severity: 'error', message, ...extra });
+    };
+    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`);
+        return { status: 'failed', diagnostics, planId: null, programId };
+    }
+    installHeadlessDocument();
+    let dom;
+    let Component;
+    try {
+        dom = await import(pathToFileURL(path.join(ctx.outDir, 'vmz-dom.js')).href);
+        Component = (await import(pathToFileURL(arts.clientPath).href)).default;
+    }
+    catch (e) {
+        fail(`import dist: ${e instanceof Error ? e.message : String(e)}`);
+        return { status: 'error', diagnostics, planId: null, programId };
+    }
+    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
+    if (components) {
+        const map = {};
+        for (const [name, chunk] of Object.entries(components)) {
+            const cArts = resolveChunkArtifacts(ctx.outDir, chunk);
+            if (!cArts.clientPath) {
+                fail(`missing component ${chunk}`);
+                continue;
+            }
+            map[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
+        }
+        dom.registerComponents(map);
+    }
+    let html = '';
+    let streamChunks = [];
+    let streamAborted = false;
+    let streamPullGapsMs = [];
+    let lastSsrProps = {};
+    let app = document.getElementById('app');
+    let inst = null;
+    let nodeBefore = null;
+    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 || '');
+        try {
+            if (kind === 'ssr' || kind === 'renderToString') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                lastSsrProps = props;
+                html = await dom.renderToString(Component, props);
+                streamChunks = [];
+                streamAborted = false;
+                streamPullGapsMs = [];
+                continue;
+            }
+            if (kind === 'renderToStream' || kind === 'stream') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                lastSsrProps = props;
+                if (typeof dom.renderToStream !== 'function') {
+                    fail('renderToStream missing from vmz-dom (rebuild example dist)');
+                    continue;
+                }
+                streamChunks = [];
+                streamAborted = false;
+                streamPullGapsMs = [];
+                const abortAfter = a.abortAfterChunks != null ? Number(a.abortAfterChunks) : NaN;
+                const pullDelayMs = a.pullDelayMs != null ? Number(a.pullDelayMs) : 0;
+                const ac = new AbortController();
+                let lastPullAt = 0;
+                for await (const chunk of dom.renderToStream(Component, props, {
+                    signal: ac.signal,
+                })) {
+                    const now = Date.now();
+                    if (lastPullAt > 0)
+                        streamPullGapsMs.push(now - lastPullAt);
+                    lastPullAt = now;
+                    streamChunks.push(String(chunk));
+                    if (Number.isFinite(abortAfter) && streamChunks.length >= abortAfter) {
+                        ac.abort();
+                        streamAborted = true;
+                        break;
+                    }
+                    if (pullDelayMs > 0) {
+                        await new Promise((r) => setTimeout(r, pullDelayMs));
+                    }
+                }
+                if (ac.signal.aborted)
+                    streamAborted = true;
+                html = streamChunks.join('');
+                continue;
+            }
+            if (kind === 'hydrate') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                if (!html) {
+                    html = await dom.renderToString(Component, props);
+                }
+                document.body.innerHTML = `<div id="app">${html}</div>`;
+                app = document.getElementById('app');
+                if (!app) {
+                    fail('hydrate #app missing');
+                    continue;
+                }
+                const sel = typeof a.identitySelector === 'string' ? a.identitySelector : 'button';
+                nodeBefore = app.querySelector(sel);
+                inst = await dom.hydrate(Component, app, props);
+                continue;
+            }
+            if (kind === 'mount') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                if (!app)
+                    app = document.getElementById('app');
+                inst = await dom.mount(Component, app, props);
+                continue;
+            }
+            if (kind === 'write') {
+                if (!inst) {
+                    fail('write before hydrate/mount');
+                    continue;
+                }
+                inst[String(a.field || '')] = a.value;
+                continue;
+            }
+            if (kind === 'flush') {
+                if (!inst) {
+                    fail('flush before hydrate/mount');
+                    continue;
+                }
+                await dom.flushPending(inst);
+                continue;
+            }
+            if (kind === 'click') {
+                if (!app) {
+                    fail('click before hydrate');
+                    continue;
+                }
+                const sel = typeof a.selector === 'string' ? a.selector : 'button';
+                const el = app.querySelector(sel);
+                if (!el) {
+                    fail(`click: no ${sel}`);
+                    continue;
+                }
+                el.click();
+                continue;
+            }
+            fail(`unknown ssr action ${JSON.stringify(kind)}`);
+        }
+        catch (e) {
+            fail(`action ${kind}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    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 === 'html') {
+            if (expect.contains != null && !html.includes(String(expect.contains))) {
+                fail(`html contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(html)}`);
+            }
+            if (expect.notContains != null && html.includes(String(expect.notContains))) {
+                fail(`html notContains ${JSON.stringify(expect.notContains)}`);
+            }
+            if (expect.equals != null && html !== String(expect.equals)) {
+                fail(`html equals want ${JSON.stringify(expect.equals)}, got ${JSON.stringify(html)}`);
+            }
+            continue;
+        }
+        if (kind === 'stream') {
+            if (streamChunks.length === 0 && !html && expect.aborted !== true) {
+                fail('stream assertion without renderToStream action');
+                continue;
+            }
+            if (expect.chunkCountMin != null && streamChunks.length < Number(expect.chunkCountMin)) {
+                fail(`stream.chunkCountMin want >= ${expect.chunkCountMin}, got ${streamChunks.length}`);
+            }
+            if (expect.chunkCountMax != null && streamChunks.length > Number(expect.chunkCountMax)) {
+                fail(`stream.chunkCountMax want <= ${expect.chunkCountMax}, got ${streamChunks.length}`);
+            }
+            if (expect.aborted === true && !streamAborted) {
+                fail('stream.aborted want true, got false');
+            }
+            if (expect.aborted === false && streamAborted) {
+                fail('stream.aborted want false, got true');
+            }
+            if (expect.pullGapMinMs != null) {
+                const minGap = Number(expect.pullGapMinMs);
+                const ok = streamPullGapsMs.some((g) => g >= minGap);
+                if (!ok) {
+                    fail(`stream.pullGapMinMs want >= ${minGap} between pulls, gaps=${JSON.stringify(streamPullGapsMs)}`);
+                }
+            }
+            if (expect.equalsRenderToString === true) {
+                const asString = await dom.renderToString(Component, lastSsrProps);
+                if (html !== asString) {
+                    fail(`stream join !== renderToString\nstream: ${JSON.stringify(html)}\nstring: ${JSON.stringify(asString)}`);
+                }
+            }
+            if (expect.firstChunkContains != null) {
+                const first = streamChunks[0] || '';
+                if (!first.includes(String(expect.firstChunkContains))) {
+                    fail(`stream.firstChunkContains want ${JSON.stringify(expect.firstChunkContains)}, got ${JSON.stringify(first)}`);
+                }
+            }
+            continue;
+        }
+        if (kind === 'text') {
+            const text = app?.textContent ?? '';
+            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 after = app?.querySelector(sel) ?? null;
+            if (!nodeBefore || !after || after !== nodeBefore) {
+                fail(`nodeIdentity failed for ${sel}`);
+            }
+            continue;
+        }
+        if (kind === 'graph' || kind === 'plan' || kind === 'view' || kind === 'diagnostic') {
+            continue;
+        }
+        fail(`unknown ssr assertion ${JSON.stringify(kind)}`);
+    }
+    const failed = diagnostics.some((d) => d.severity === 'error');
+    return {
+        status: failed ? 'failed' : 'passed',
+        diagnostics,
+        planId: null,
+        programId,
+    };
+}