@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/nuxt-evidence.js

@@ -0,0 +1,160 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { z } from "zod";
+import { nuxtConfigSchema, nuxtVersions } from "./nuxt.js";
+import { nuxtResultSchema } from "./nuxt-protocol.js";
+import { vueRouteAttributesSchema, vueRouteKey, } from "./vue-router-protocol.js";
+export function nuxtEvidence(check, processes) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "Nuxt SSR capture, stable assembly or route participation evidence is incomplete.",
+        findingsComplete: false,
+    };
+    if (processes.length !== 1)
+        return incomplete;
+    const execution = processes[0];
+    if (execution.exitCode === 3) {
+        try {
+            z.strictObject({
+                unavailable: z.literal("nuxt-runtime"),
+                reason: z.literal("unsupported-version"),
+            }).parse(JSON.parse(execution.stdout));
+            return {
+                status: "unavailable",
+                reason: "The verified Nuxt runtime versions are not installed.",
+                findingsComplete: false,
+            };
+        }
+        catch {
+            return incomplete;
+        }
+    }
+    if (execution.exitCode !== 0)
+        return {
+            status: "error",
+            reason: "Nuxt build or SSR capture failed.",
+            findingsComplete: false,
+        };
+    try {
+        const result = nuxtResultSchema.parse(JSON.parse(execution.stdout));
+        const config = nuxtConfigSchema.parse(JSON.parse(check.commands[0].args[3]));
+        if (result.sourceFingerprint !== check.commands[0].args[4] ||
+            result.probes.length !== config.probes.length ||
+            Object.keys(result.versions).length !==
+                Object.keys(nuxtVersions).length ||
+            Object.entries(nuxtVersions).some(([name, version]) => result.versions[name] !== version))
+            return incomplete;
+        const collection = result.runtime?.collections[0];
+        const entries = collection?.entries ?? [];
+        if (result.runtime) {
+            if (result.runtime.sourceFingerprint !== result.sourceFingerprint ||
+                result.runtime.producer.name !== "checktrail.nuxt" ||
+                result.runtime.producer.version !== "1.0.0" ||
+                result.runtime.assembly.name !== config.assembly ||
+                result.runtime.assembly.environment !== config.environment ||
+                result.runtime.collections.length !== 1 ||
+                collection?.kind !== "routes" ||
+                !collection.ordered ||
+                collection.complete !== (entries.length === result.totalRoutes) ||
+                result.indices.length !== entries.length ||
+                result.indices.some((value, index) => value >= result.totalRoutes ||
+                    (index > 0 && value <= result.indices[index - 1])))
+                return incomplete;
+            const signature = createHash("sha256")
+                .update(JSON.stringify({
+                totalRoutes: result.totalRoutes,
+                indices: result.indices,
+                entries,
+            }))
+                .digest("hex");
+            if (result.signature !== signature)
+                return incomplete;
+        }
+        else if (result.totalRoutes ||
+            result.indices.length ||
+            result.signature !== null)
+            return incomplete;
+        const records = new Map();
+        for (const [offset, entry] of entries.entries()) {
+            const attributes = vueRouteAttributesSchema.parse(entry.attributes);
+            if (entry.key !== vueRouteKey(attributes))
+                return incomplete;
+            records.set(result.indices[offset], {
+                path: attributes.path,
+                name: attributes.name,
+            });
+        }
+        const observed = new Set();
+        const findings = [];
+        let capturesComplete = Boolean(collection?.complete && result.totalRoutes);
+        for (const [index, probe] of result.probes.entries()) {
+            const expected = config.probes[index];
+            if (probe.path !== expected.path)
+                return incomplete;
+            const file = path.posix.join(check.project, "checktrail.nuxt.json");
+            if (probe.status !== 200)
+                findings.push({
+                    ruleId: "nuxt/http-status",
+                    level: "error",
+                    file,
+                    message: `SSR request ${probe.path} returned HTTP ${probe.status}, expected HTTP 200.`,
+                });
+            if (!probe.capture) {
+                capturesComplete = false;
+                continue;
+            }
+            const capture = probe.capture;
+            if (!result.runtime ||
+                capture.signature !== result.signature ||
+                capture.totalRoutes !== result.totalRoutes ||
+                capture.supportedRoutes !== entries.length)
+                capturesComplete = false;
+            if (capture.indices.length !== capture.matched.length)
+                return incomplete;
+            const nonnull = capture.indices.filter((value) => value !== null);
+            if (new Set(nonnull).size !== nonnull.length ||
+                nonnull.some((value) => value >= capture.totalRoutes))
+                return incomplete;
+            if (capture.signature === result.signature) {
+                for (const [offset, recordIndex] of capture.indices.entries()) {
+                    if (recordIndex === null)
+                        continue;
+                    if (records.has(recordIndex) &&
+                        JSON.stringify(records.get(recordIndex)) !==
+                            JSON.stringify(capture.matched[offset]))
+                        return incomplete;
+                    observed.add(recordIndex);
+                }
+            }
+            if (JSON.stringify(capture.matched) !== JSON.stringify(expected.matched))
+                findings.push({
+                    ruleId: "nuxt/probe-mismatch",
+                    level: "error",
+                    file,
+                    message: `SSR request ${probe.path} did not render its declared matched route chain.`,
+                });
+        }
+        const complete = capturesComplete && observed.size === result.totalRoutes;
+        const evidence = {
+            ...(result.runtime ? { runtime: result.runtime } : {}),
+            findings,
+            findingsComplete: complete,
+        };
+        if (findings.length)
+            return {
+                ...evidence,
+                status: "failed",
+                reason: "Nuxt SSR requests differ from the declared route contract.",
+            };
+        if (!complete)
+            return { ...evidence, ...incomplete };
+        return {
+            ...evidence,
+            status: "passed",
+            reason: "Every native route participated in a successful SSR request and all matched chains agreed with the declared contract.",
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

package/dist/src/nuxt-protocol.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const nuxtResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    versions: z.ZodRecord<z.ZodString, z.ZodString>;
+    sourceFingerprint: z.ZodString;
+    runtime: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        format: z.ZodLiteral<"runtime-inventory">;
+        producer: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        assembly: z.ZodObject<{
+            name: z.ZodString;
+            environment: z.ZodString;
+        }, z.core.$strict>;
+        sourceFingerprint: z.ZodString;
+        capturedAt: z.ZodISODateTime;
+        collections: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                routes: "routes";
+                listeners: "listeners";
+                middleware: "middleware";
+                schedules: "schedules";
+                bindings: "bindings";
+            }>;
+            complete: z.ZodBoolean;
+            ordered: z.ZodBoolean;
+            entries: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    totalRoutes: z.ZodNumber;
+    indices: z.ZodArray<z.ZodNumber>;
+    signature: z.ZodNullable<z.ZodString>;
+    probes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodNumber;
+        capture: z.ZodNullable<z.ZodObject<{
+            signature: z.ZodString;
+            totalRoutes: z.ZodNumber;
+            supportedRoutes: z.ZodNumber;
+            matched: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                name: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            indices: z.ZodArray<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/src/nuxt-protocol.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { runtimeInventorySchema } from "./runtime-inventory.js";
+import { vueRouteIdentitySchema } from "./vue-router.js";
+const count = z.number().int().nonnegative().max(2048);
+const signature = z.string().regex(/^[a-f0-9]{64}$/);
+export const nuxtResultSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    versions: z.record(z.string(), z.string()),
+    sourceFingerprint: signature,
+    runtime: runtimeInventorySchema.nullable(),
+    totalRoutes: count,
+    indices: z.array(count).max(2048),
+    signature: signature.nullable(),
+    probes: z
+        .array(z.strictObject({
+        path: z.string(),
+        status: z.number().int().min(100).max(599),
+        capture: z
+            .strictObject({
+            signature,
+            totalRoutes: count,
+            supportedRoutes: count,
+            matched: z.array(vueRouteIdentitySchema).max(32),
+            indices: z.array(count.nullable()).max(32),
+        })
+            .nullable(),
+    }))
+        .max(16),
+});

package/dist/src/nuxt-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/nuxt-runner.js

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { writeSync } from "node:fs";
+import { readFile, realpath, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { nuxtConfigSchema, nuxtVersions } from "./nuxt.js";
+import { nuxtResultSchema } from "./nuxt-protocol.js";
+import { captureVueRecords, vueRecordIdentity, } from "./vue-router-capture.js";
+const symbol = Symbol.for("checktrail.nuxt.capture");
+const host = globalThis;
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+async function main() {
+    const [entry, encodedMetadata, encodedConfig, sourceFingerprint] = process.argv.slice(2);
+    const config = nuxtConfigSchema.parse(JSON.parse(encodedConfig));
+    const metadata = JSON.parse(encodedMetadata);
+    const versions = {};
+    for (const [name, expected] of Object.entries(nuxtVersions)) {
+        versions[name] = JSON.parse(await readFile(metadata[name], "utf8")).version;
+        if (versions[name] !== expected) {
+            writeSync(1, JSON.stringify({
+                unavailable: "nuxt-runtime",
+                reason: "unsupported-version",
+            }));
+            process.exitCode = 3;
+            return;
+        }
+    }
+    const temporary = await realpath(process.env.CHECKTRAIL_TEMP);
+    const root = await realpath(process.cwd());
+    const buildDir = path.join(temporary, "build");
+    const serverDir = path.join(temporary, "server");
+    const plugin = path.join(temporary, "capture.mjs");
+    await writeFile(plugin, `import {defineNuxtPlugin} from '#app';
+export default defineNuxtPlugin({name:'checktrail-capture',dependsOn:['nuxt:router'],enforce:'pre',setup(app){
+ const router=app.$router; const records=router.getRoutes.bind(router);
+ app.hook('app:rendered',()=>globalThis[Symbol.for('checktrail.nuxt.capture')]?.(()=>({records:records(),matched:router.currentRoute.value.matched,strict:router.options.strict??false,sensitive:router.options.sensitive??false,url:app.ssrContext.url})));
+}});`);
+    const { loadNuxt, build } = (await import(pathToFileURL(entry).href));
+    let nuxt;
+    let runtime;
+    try {
+        nuxt = await loadNuxt({
+            cwd: root,
+            dotenv: false,
+            overrides: {
+                dev: false,
+                test: true,
+                ssr: true,
+                telemetry: false,
+                devtools: { enabled: false },
+                builder: "@nuxt/vite-builder",
+                buildDir,
+                plugins: [{ src: plugin, mode: "server" }],
+                vite: { cacheDir: path.join(temporary, "vite") },
+                nitro: {
+                    preset: "nitro-prerender",
+                    output: {
+                        dir: path.join(temporary, "output"),
+                        serverDir,
+                        publicDir: path.join(temporary, "public"),
+                    },
+                    prerender: { crawlLinks: false, routes: [] },
+                },
+                experimental: {
+                    buildCache: false,
+                    typescriptPlugin: false,
+                    chromeDevtoolsProjectSettings: false,
+                },
+            },
+        });
+        if (nuxt.options.dev ||
+            !nuxt.options.test ||
+            !nuxt.options.ssr ||
+            nuxt.options.buildDir !== buildDir ||
+            nuxt.options.rootDir !== root)
+            throw new Error("Nuxt testing assembly settings changed");
+        await build(nuxt);
+        runtime = await import(pathToFileURL(path.join(serverDir, "index.mjs")).href);
+        const result = {
+            schemaVersion: 1,
+            versions,
+            sourceFingerprint,
+            runtime: null,
+            totalRoutes: 0,
+            indices: [],
+            signature: null,
+            probes: [],
+        };
+        for (const probe of config.probes) {
+            const captures = [];
+            host[symbol] = (capture) => {
+                if (captures.length >= 2)
+                    throw new Error("Repeated runtime capture");
+                captures.push(capture);
+            };
+            const response = await runtime.localFetch(probe.path, {
+                headers: { host: "checktrail.invalid" },
+            });
+            await response.body?.cancel();
+            let capture = null;
+            const native = captures.length === 1 ? captures[0]() : undefined;
+            if (native?.url === probe.path) {
+                if (native.records.length > 2048 ||
+                    typeof native.strict !== "boolean" ||
+                    typeof native.sensitive !== "boolean")
+                    throw new Error("Unsupported native router");
+                const { entries, indices } = captureVueRecords(native.records, native);
+                const signature = hash({
+                    totalRoutes: native.records.length,
+                    indices,
+                    entries,
+                });
+                if (!result.runtime) {
+                    result.totalRoutes = native.records.length;
+                    result.indices = indices;
+                    result.signature = signature;
+                    result.runtime = {
+                        schemaVersion: 1,
+                        format: "runtime-inventory",
+                        producer: { name: "checktrail.nuxt", version: "1.0.0" },
+                        assembly: {
+                            name: config.assembly,
+                            environment: config.environment,
+                        },
+                        sourceFingerprint,
+                        capturedAt: new Date().toISOString(),
+                        collections: [
+                            {
+                                kind: "routes",
+                                ordered: true,
+                                complete: entries.length === native.records.length,
+                                entries,
+                            },
+                        ],
+                    };
+                }
+                capture = {
+                    signature,
+                    totalRoutes: native.records.length,
+                    supportedRoutes: entries.length,
+                    matched: native.matched.map(vueRecordIdentity),
+                    indices: native.matched.map((record) => {
+                        const index = native.records.indexOf(record);
+                        return index < 0 ? null : index;
+                    }),
+                };
+            }
+            result.probes.push({
+                path: probe.path,
+                status: response.status,
+                capture,
+            });
+        }
+        writeSync(1, JSON.stringify(nuxtResultSchema.parse(result)));
+    }
+    finally {
+        delete host[symbol];
+        await runtime?.closePrerenderer();
+        await nuxt?.close();
+    }
+}
+main().catch(() => {
+    writeSync(2, "Nuxt build or SSR runtime capture could not complete\n");
+    process.exitCode = 2;
+});

package/dist/src/nuxt.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { Check, Inventory, Project } from "./types.js";
+export declare const nuxtVersions: {
+    readonly nuxt: "4.5.2";
+    readonly "@nuxt/kit": "4.5.2";
+    readonly "@nuxt/vite-builder": "4.5.2";
+    readonly "@nuxt/nitro-server": "4.5.2";
+    readonly nitropack: "2.13.4";
+    readonly vue: "3.5.43";
+    readonly "vue-router": "5.3.1";
+};
+export declare const nuxtConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    assembly: z.ZodString;
+    environment: z.ZodLiteral<"test">;
+    probes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        matched: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function nuxtCheck(source: Inventory, project: Project): Promise<Check>;

package/dist/src/nuxt.js

@@ -0,0 +1,105 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { localTool } from "./local-tool.js";
+import { readProjectFile, withinRoot } from "./inventory.js";
+import { vueRouteIdentitySchema } from "./vue-router.js";
+export const nuxtVersions = {
+    nuxt: "4.5.2",
+    "@nuxt/kit": "4.5.2",
+    "@nuxt/vite-builder": "4.5.2",
+    "@nuxt/nitro-server": "4.5.2",
+    nitropack: "2.13.4",
+    vue: "3.5.43",
+    "vue-router": "5.3.1",
+};
+export const nuxtConfigSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    assembly: z.string().min(1).max(256),
+    environment: z.literal("test"),
+    probes: z
+        .array(z.strictObject({
+        path: z
+            .string()
+            .regex(/^\/(?!\/)[^\r\n#]*$/)
+            .max(4096),
+        matched: z.array(vueRouteIdentitySchema).min(1).max(32),
+    }))
+        .min(1)
+        .max(16),
+});
+export async function nuxtCheck(source, project) {
+    const check = {
+        id: "javascript.nuxt-runtime",
+        adapter: project.adapter,
+        project: project.path,
+        kind: "analysis",
+        parser: "nuxt-json",
+        scope: [],
+        commands: [],
+        reason: "Build an isolated Nuxt SSR testing assembly and verify declared requests against its native runtime router.",
+    };
+    if (!project.files.includes("checktrail.nuxt.json")) {
+        check.unavailableReason =
+            "Nuxt runtime checks require an explicit checktrail.nuxt.json profile.";
+        return check;
+    }
+    const config = nuxtConfigSchema.parse(JSON.parse(await readProjectFile(source.root, path.posix.join(project.path, "checktrail.nuxt.json"))));
+    if (new Set(config.probes.map((probe) => probe.path)).size !==
+        config.probes.length)
+        throw new Error("Nuxt probes require unique request paths");
+    const encoded = JSON.stringify(config);
+    if (Buffer.byteLength(encoded) > 64 * 1024)
+        throw new Error("Nuxt profile exceeds 64 KiB");
+    const configs = project.files.filter((file) => /^nuxt\.config\.[cm]?[jt]s$/.test(file));
+    if (configs.length !== 1) {
+        check.unavailableReason =
+            "Nuxt runtime checks require exactly one inventoried root Nuxt configuration.";
+        return check;
+    }
+    check.scope = configs;
+    const entry = await localTool(source.root, project.path, "nuxt/dist/index.mjs");
+    if (!entry) {
+        check.unavailableReason =
+            "Nuxt must already be installed inside the configured root.";
+        return check;
+    }
+    const metadata = {};
+    try {
+        const require = createRequire(entry);
+        for (const name of Object.keys(nuxtVersions)) {
+            const resolver = name === "nitropack"
+                ? createRequire(metadata["@nuxt/nitro-server"])
+                : require;
+            const resolved = resolver.resolve(`${name}/package.json`);
+            metadata[name] = await withinRoot(source.root, path.relative(source.root, resolved));
+        }
+    }
+    catch {
+        check.unavailableReason =
+            "Nuxt runtime dependencies must resolve inside the configured root.";
+        return check;
+    }
+    check.commands = [
+        {
+            executable: process.execPath,
+            args: [
+                fileURLToPath(new URL("./nuxt-runner.js", import.meta.url)),
+                entry,
+                JSON.stringify(metadata),
+                encoded,
+                source.fingerprint,
+            ],
+            cwd: project.path,
+            env: {
+                NODE_ENV: "test",
+                NODE_OPTIONS: "",
+                NUXT_TELEMETRY_DISABLED: "1",
+                CI: "1",
+            },
+            temporaryDirectory: true,
+        },
+    ];
+    return check;
+}

package/dist/src/output.d.ts

@@ -0,0 +1,3 @@
+import type { Plan, Report } from "./types.js";
+export declare function projectPlan(plan: Plan, detailed: boolean): Record<string, unknown>;
+export declare function projectReport(report: Report, detailed: boolean): Record<string, unknown>;

package/dist/src/output.js

@@ -0,0 +1,48 @@
+function selectionSummary(selection) {
+    return selection
+        ? {
+            selection: {
+                mode: selection.mode,
+                reason: selection.reason,
+                projectCount: selection.selectedProjects.length,
+                changedFileCount: selection.changedFiles.length,
+            },
+        }
+        : {};
+}
+export function projectPlan(plan, detailed) {
+    if (detailed)
+        return { ...plan };
+    return {
+        ...selectionSummary(plan.selection),
+        schemaVersion: plan.schemaVersion,
+        engineVersion: plan.engineVersion,
+        projectCount: plan.projects.length,
+        adapters: [...new Set(plan.projects.map((project) => project.adapter))],
+        excludedCount: plan.excluded.length,
+        checks: plan.checks.map((check) => ({
+            id: check.id,
+            kind: check.kind,
+            ready: !check.unavailableReason,
+        })),
+    };
+}
+export function projectReport(report, detailed) {
+    if (detailed)
+        return { ...report };
+    return {
+        ...selectionSummary(report.selection),
+        schemaVersion: report.schemaVersion,
+        engineVersion: report.engineVersion,
+        runId: report.runId,
+        outcome: report.outcome,
+        durationMs: report.durationMs,
+        sourceChanged: report.sourceChanged,
+        sourceError: report.sourceError,
+        checks: report.checks.map((check) => ({
+            id: check.id,
+            status: check.status,
+            ...(check.tests ? { tests: check.tests } : {}),
+        })),
+    };
+}

package/dist/src/phpstan-evidence.d.ts

@@ -0,0 +1,2 @@
+import type { Check, CheckResult, ProcessResult } from "./types.js";
+export declare function phpstanEvidence(check: Check, processes: ProcessResult[], root: string | undefined): Pick<CheckResult, "status" | "reason" | "findings" | "findingsComplete">;

package/dist/src/phpstan-evidence.js

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { z } from "zod";
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const schema = z.object({
+    totals: z.object({ errors: count, file_errors: count }),
+    files: z.record(z.string(), z.object({
+        errors: count,
+        messages: z.array(z.object({
+            message: z.string(),
+            line: z.number().int().positive().nullable(),
+            ignorable: z.boolean(),
+            identifier: z.string().min(1).optional(),
+        })),
+    })),
+    errors: z.array(z.string()),
+});
+export function phpstanEvidence(check, processes, root) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "PHPStan output does not account for every planned file or consistent diagnostic totals.",
+    };
+    if (!root || processes.length !== 1 || !check.scope.length)
+        return incomplete;
+    const process = processes[0];
+    const lines = process.stdout.split(/\r?\n/).filter(Boolean);
+    let report;
+    try {
+        report = schema.parse(JSON.parse(lines.pop() ?? ""));
+    }
+    catch {
+        return process.exitCode === 0
+            ? incomplete
+            : {
+                status: "error",
+                reason: "PHPStan could not produce native analysis evidence; inspect configuration and runtime errors.",
+            };
+    }
+    if (process.exitCode !== 0 && process.exitCode !== 1)
+        return { status: "error", reason: "PHPStan did not exit normally." };
+    const expected = new Set(check.scope.map((file) => path.resolve(root, check.project, file)));
+    let errors = 0;
+    const findings = [];
+    for (const [file, result] of Object.entries(report.files)) {
+        if (!expected.has(file) || result.errors !== result.messages.length)
+            return incomplete;
+        errors += result.errors;
+        findings.push(...result.messages.map((message) => ({
+            ruleId: message.identifier ?? "diagnostic",
+            level: "error",
+            message: message.message,
+            file: path.relative(root, file).split(path.sep).join("/"),
+            ...(message.line ? { line: message.line } : {}),
+        })));
+    }
+    if (errors !== report.totals.file_errors ||
+        report.errors.length !== report.totals.errors)
+        return incomplete;
+    const complete = lines.length === expected.size &&
+        new Set(lines).size === expected.size &&
+        lines.every((file) => expected.has(file)) &&
+        !process.stderr.trim();
+    if (errors || report.errors.length || process.exitCode === 1)
+        return {
+            status: "failed",
+            reason: "PHPStan reported analysis diagnostics.",
+            findings,
+            findingsComplete: complete &&
+                errors > 0 &&
+                !report.errors.length &&
+                process.exitCode === 1 &&
+                Object.values(report.files).every((file) => file.messages.every((message) => message.ignorable)),
+        };
+    if (!complete)
+        return incomplete;
+    return {
+        status: "passed",
+        findings,
+        findingsComplete: true,
+        reason: "PHPStan analysed every planned file and reported no diagnostics.",
+    };
+}