import { spawnSync } from "node:child_process"; import { createHash } from "node:crypto"; import { existsSync } from "node:fs"; import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises"; import { arch, platform, userInfo } from "node:os"; import path from "node:path"; import { selectRepositoryPaths } from "./lib/repository-layout.ts"; /** * Executable evidence for the extreme-scale acceptance matrix. * * Runs every gate the acceptance rows cite, in order, under the *current* * Node, and writes one machine-readable record: * artifacts/quality/extreme-scale-gates.json * artifacts/quality/extreme-scale-gates/.log * * On an unsupported Node the gates are not run at all and the record says * `not-executed`; it is never reported as a failure of the code or as a pass. * In an environment whose default Node is too old, put a supported binary * first on PATH (for example a repository-local `.tmp/node24/bin`). */ export const EXTREME_SCALE_GATES = Object.freeze([ "check:feature-index", "check:types:app", "check:types:test", "check:types", "lint", "check:architecture", "check:app-build-input", "check:request-fanout", "check:registries", "check:diagnostics", "test:extreme-scale:focused", "check:topology", "check:traffic", "check:observability", "check:release-coherence", "test:platform", "check:scale:pr", "check:scale:main", "check:scale:baseline", // The soak needs a build of the current source, never a stale dist/. "build", // The production bundle closure of the built app contains only its features. "check:app-build-input:bundle", "check:scale:nightly", "check:scale:release", ] as const); /** Inputs whose content defines "the current code": the scale-source set of config/repository-layout.json (R2). */ const SOURCE_PATHS = selectRepositoryPaths("scale-source"); async function listFiles(directory: string): Promise { const found: string[] = []; let entries; try { entries = await readdir(directory, { withFileTypes: true }); } catch { return found; } for (const entry of entries) { const target = path.join(directory, entry.name); if (entry.isDirectory()) found.push(...(await listFiles(target))); else if (entry.isFile()) found.push(target); } return found; } /** sha256 over every source input (path + content), in a stable order. */ export async function sourceDigest(root: string): Promise> { const files = [ ...( await Promise.all( SOURCE_PATHS.map((entry) => path.join(root, entry)).map(async (target) => (await stat(target).catch(() => null))?.isDirectory() ? listFiles(target) : existsSync(target) ? [target] : [], ), ) ).flat(), ] .map((file) => path.relative(root, file)) .sort(); const hash = createHash("sha256"); for (const file of files) { hash.update(file).update("\0").update(await readFile(path.join(root, file))).update("\0"); } return { digest: hash.digest("hex"), files: files.length }; } /** Sums vitest `Tests N passed` / `N failed` lines from a gate log. */ export function vitestCounts(log: string): Readonly<{ passed: number; failed: number; skipped: number; files: number }> { const escape = String.fromCharCode(27); const plain = log.split(escape).map((part, index) => (index === 0 ? part : part.replace(/^\[[0-9;]*m/u, ""))).join(""); let passed = 0; let failed = 0; let skipped = 0; let files = 0; for (const line of plain.split("\n")) { const tests = /^\s*Tests\s+(.*)$/u.exec(line); if (tests) { passed += Number(/(\d+) passed/u.exec(tests[1] as string)?.[1] ?? 0); failed += Number(/(\d+) failed/u.exec(tests[1] as string)?.[1] ?? 0); skipped += Number(/(\d+) skipped/u.exec(tests[1] as string)?.[1] ?? 0); } const fileLine = /^\s*Test Files\s+.*?(\d+) passed/u.exec(line); if (fileLine) files += Number(fileLine[1]); } return { passed, failed, skipped, files }; } type Version = readonly [number, number, number]; function parseVersion(value: string): Version { const [major = 0, minor = 0, patch = 0] = value.replace(/^v/u, "").split(".").map(Number); return [major, minor, patch]; } function compare(left: Version, right: Version): number { for (let index = 0; index < 3; index += 1) { const difference = (left[index] ?? 0) - (right[index] ?? 0); if (difference !== 0) return difference; } return 0; } /** Supports the `>=a.b.c =|<=|>|<|=)?(\d+(?:\.\d+){0,2})$/u.exec(clause); if (!match) return false; const order = compare(current, parseVersion(match[2] as string)); const operator = match[1] ?? "="; const ok = operator === ">=" ? order >= 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : operator === "<" ? order < 0 : order === 0; if (!ok) return false; } return true; } async function main(): Promise { const root = process.cwd(); const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8")) as { engines?: { node?: string }; }; const engine = pkg.engines?.node ?? ""; const directory = path.join(root, "artifacts/quality/extreme-scale-gates"); const artifact = path.join(root, "artifacts/quality/extreme-scale-gates.json"); await mkdir(directory, { recursive: true }); const startedAt = new Date(); const pnpmVersion = spawnSync("corepack", ["pnpm", "--version"], { cwd: root, encoding: "utf8" }).stdout?.trim() ?? ""; const identity = { node: process.version, nodeMajor: Number(process.versions.node.split(".")[0]), pnpm: pnpmVersion, engine, platform: platform(), arch: arch(), user: (() => { try { return userInfo().username; } catch { return "unknown"; } })(), }; if (!satisfiesEngine(process.version, engine)) { await writeFile( artifact, `${JSON.stringify( { schemaVersion: 1, generatedAt: new Date().toISOString(), ...identity, status: "not-executed", reason: `Node ${process.version} does not satisfy engines.node "${engine}"`, gates: [], }, null, 2, )}\n`, ); process.stderr.write( `not executed: Node ${process.version} does not satisfy "${engine}". Put a supported node first on PATH.\n`, ); process.exit(2); } const browsers = path.join(root, ".tmp/ms-playwright"); const env = { ...process.env, pnpm_config_verify_deps_before_run: "false", ...(process.env["PLAYWRIGHT_BROWSERS_PATH"] === undefined && existsSync(browsers) ? { PLAYWRIGHT_BROWSERS_PATH: browsers } : {}), }; const only = process.argv.find((argument) => argument.startsWith("--only="))?.slice(7).split(","); const gates = only ? EXTREME_SCALE_GATES.filter((gate) => only.includes(gate)) : EXTREME_SCALE_GATES; const sourceBefore = await sourceDigest(root); const results: { gate: string; status: "passed" | "failed"; exitCode: number | null; durationMs: number; tests: ReturnType; log: string; }[] = []; for (const gate of gates) { const gateStartedAt = Date.now(); const run = spawnSync("corepack", ["pnpm", "run", gate], { cwd: root, env, encoding: "utf8", maxBuffer: 256 * 1024 * 1024, }); const log = path.join(directory, `${gate.replaceAll(":", "-")}.log`); await writeFile(log, `${run.stdout ?? ""}${run.stderr ?? ""}`); const status = run.status === 0 ? "passed" : "failed"; const tests = vitestCounts(`${run.stdout ?? ""}${run.stderr ?? ""}`); results.push({ gate, status, exitCode: run.status, durationMs: Date.now() - gateStartedAt, tests, log: path.relative(root, log), }); process.stdout.write( `${status.toUpperCase()} ${gate} (${Date.now() - gateStartedAt}ms${tests.passed + tests.failed > 0 ? `, ${tests.passed} tests passed, ${tests.failed} failed` : ""})\n`, ); } const sourceAfter = await sourceDigest(root); const readJson = async (relative: string) => { const file = path.join(root, relative); if (!existsSync(file)) return null; const fresh = (await stat(file)).mtimeMs >= startedAt.getTime(); return { fresh, value: JSON.parse(await readFile(file, "utf8")) as Record }; }; // Machine-readable artifacts the acceptance depends on must be produced by // this run, on this Node, and say passed. An old PASS is not evidence. const evidenceChecks: { artifact: string; check: string; passed: boolean }[] = []; const expect = (artifact: string, check: string, passed: boolean) => evidenceChecks.push({ artifact, check, passed }); const ran = new Set(gates); for (const tier of ["nightly", "release"] as const) { if (!ran.has(`check:scale:${tier}`)) continue; const relative = `artifacts/scale/${tier}/summary.json`; const summary = await readJson(relative); expect(relative, "regenerated during this run", summary?.fresh === true); expect(relative, "status passed with no skipped step", summary?.value["status"] === "passed" && Array.isArray(summary.value["skipped"]) && summary.value["skipped"].length === 0); const environment = summary?.value["environment"] as { nodeMajor?: number } | undefined; expect(relative, `environment.nodeMajor == ${identity.nodeMajor}`, environment?.nodeMajor === identity.nodeMajor); } const soakRecord = ran.has("check:scale:nightly") ? await readJson("artifacts/scale/nightly/browser-soak.json") : null; if (ran.has("check:scale:nightly")) { expect("artifacts/scale/nightly/browser-soak.json", "regenerated during this run", soakRecord?.fresh === true); expect("artifacts/scale/nightly/browser-soak.json", "status passed (not skipped)", soakRecord?.value["status"] === "passed"); } if (ran.has("check:scale:baseline")) { const comparison = await readJson("artifacts/scale/baseline-comparison.json"); expect("artifacts/scale/baseline-comparison.json", "regenerated during this run", comparison?.fresh === true); expect("artifacts/scale/baseline-comparison.json", "status passed on all axes (timing compatible)", comparison?.value["status"] === "passed"); } if (ran.has("check:app-build-input:bundle")) { const inventory = await readJson("artifacts/quality/vite-module-inventory.json"); expect( "artifacts/quality/vite-module-inventory.json", "produced by this run's build (bundle isolation checked on current code)", inventory?.fresh === true, ); } expect("source tree", "unchanged while the gates ran", sourceBefore.digest === sourceAfter.digest); const soak = soakRecord?.value ?? null; const status = results.every((result) => result.status === "passed") && evidenceChecks.every((check) => check.passed) ? "passed" : "failed"; await writeFile( artifact, `${JSON.stringify( { schemaVersion: 1, generatedAt: new Date().toISOString(), startedAt: startedAt.toISOString(), ...identity, source: { digest: sourceAfter.digest, files: sourceAfter.files }, status, gates: results, totals: { gates: results.length, passedGates: results.filter((result) => result.status === "passed").length, testsPassed: results.reduce((sum, result) => sum + result.tests.passed, 0), testsFailed: results.reduce((sum, result) => sum + result.tests.failed, 0), }, evidenceChecks, browserSoak: soak ? { status: soak["status"], classification: soak["classification"], samples: Array.isArray(soak["samples"]) ? soak["samples"].length : 0, summary: soak["summary"], browser: soak["browser"], build: soak["build"], } : null, }, null, 2, )}\n`, ); process.stdout.write(`extreme-scale gates: ${status.toUpperCase()} on Node ${process.version} (${path.relative(root, artifact)})\n`); if (status !== "passed") process.exitCode = 1; } if (import.meta.url === `file://${process.argv[1]}`) { await main(); }