@beryl-so/cli 0.73.2 → 0.78.0

package/dist/local-exec.js

@@ -1,239 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { startEmailPump } from "./email-pump.js";
-import { PlaywrightMissingError, runSpecLocally, } from "./local-run.js";
-// Client-side mirrors of the server's RUN_IMPORT_* caps: stay under them rather than
-// discover them as a 413/422.
-export const IMPORT_MAX_ERROR_LEN = 5000;
-export const IMPORT_MAX_FILE_BYTES = 14 * 1024 * 1024;
-export const IMPORT_MAX_TOTAL_BYTES = 180 * 1024 * 1024;
-export const IMPORT_MAX_FILES = 3600;
-export const THIRD_PARTY_CLOUD_ONLY = "third party integration steps run only in Beryl's cloud";
-export const THIRD_PARTY_USE_TRIGGER = `${THIRD_PARTY_CLOUD_ONLY}; use \`beryl runs trigger\``;
-// The rendered await_third_party helper, and the authorize step's wait to leave the provider's host.
-const THIRD_PARTY_SPEC_MARKER = /__vmThirdParty\(|\.test\(u\.hostname\)/;
-export const specUsesThirdParty = (content) => THIRD_PARTY_SPEC_MARKER.test(content);
-export function toRunEntry(spec, outcome, runError, startedAt, ordinal, redact) {
-    // Mirrors the cloud runner's redact_result: the spec types secrets into the page
-    // and an injected session authenticates its requests, so error text and the DOM
-    // snapshot can echo them back — scrub before the bytes leave this machine. Frames
-    // and screenshots are pixels; nothing to scrub.
-    const values = (Array.isArray(redact) ? redact : [redact]).filter((v) => Boolean(v));
-    const scrub = (text) => values.reduce((out, v) => out.split(v).join("***"), text);
-    const scrubBytes = (bytes) => values.some((v) => bytes.includes(v))
-        ? Buffer.from(scrub(bytes.toString("utf8")), "utf8")
-        : bytes;
-    const completedAt = new Date().toISOString();
-    const base = {
-        test_case_id: spec.id,
-        started_at: startedAt,
-        completed_at: completedAt,
-        frames: [],
-        frame_urls: [],
-        frame_durations_ms: [],
-        files: [],
-    };
-    if (!outcome) {
-        return {
-            ...base,
-            status: "errored",
-            phase: "main",
-            error_message: scrub(runError ?? "the spec did not run").slice(0, IMPORT_MAX_ERROR_LEN),
-        };
-    }
-    const result = outcome.results[0];
-    const status = result && (result.status === "passed" || result.status === "expected")
-        ? "passed"
-        : "failed";
-    const harvested = outcome.harvested;
-    const entry = {
-        ...base,
-        status,
-        phase: status === "failed" ? (harvested?.phase ?? "main") : "main",
-        ...(result?.error
-            ? { error_message: scrub(result.error).slice(0, IMPORT_MAX_ERROR_LEN) }
-            : {}),
-        ...(result?.duration_ms !== undefined ? { duration_ms: Math.max(0, result.duration_ms) } : {}),
-    };
-    if (!harvested)
-        return entry;
-    // A frame over the per-file cap would force dropping mid-list and shift the
-    // index-aligned url/duration sidecars — drop the whole filmstrip instead.
-    // Drop the inlined sign-in's frames before anything is index-aligned to the stored
-    // plan: `runs explain` zips the plan's steps against these lists, so an off-by-K here
-    // shows every step's screenshot next to the wrong step.
-    const skip = Math.min(spec.inlinedLoginSteps ?? 0, harvested.frames.length);
-    const frames = harvested.frames.slice(skip);
-    if (frames.every((f) => f.length <= IMPORT_MAX_FILE_BYTES)) {
-        frames.forEach((bytes, i) => {
-            const name = `r${ordinal}-frame-${String(i).padStart(3, "0")}.png`;
-            entry.frames.push(name);
-            entry.files.push({ name, bytes });
-        });
-        entry.frame_urls = harvested.frameUrls.slice(skip);
-        entry.frame_durations_ms = harvested.frameDurationsMs.slice(skip);
-    }
-    if (harvested.screenshot && harvested.screenshot.length <= IMPORT_MAX_FILE_BYTES) {
-        entry.screenshot = `r${ordinal}-screenshot.png`;
-        entry.files.push({ name: entry.screenshot, bytes: harvested.screenshot });
-    }
-    if (harvested.domSnapshot && harvested.domSnapshot.length <= IMPORT_MAX_FILE_BYTES) {
-        entry.dom_snapshot = `r${ordinal}-dom.html`;
-        entry.files.push({ name: entry.dom_snapshot, bytes: scrubBytes(harvested.domSnapshot) });
-    }
-    return entry;
-}
-export function buildImportForm(entries, opts) {
-    // Total-size budget: when a big suite would blow past the server's cap, shed whole
-    // filmstrips (largest droppable payload, replay-only) test by test — never
-    // mid-list, and never silently.
-    let total = entries.flatMap((e) => e.files).reduce((n, f) => n + f.bytes.length, 0);
-    for (const entry of entries) {
-        if (total <= IMPORT_MAX_TOTAL_BYTES)
-            break;
-        const frameBytes = entry.files
-            .filter((f) => entry.frames.includes(f.name))
-            .reduce((n, f) => n + f.bytes.length, 0);
-        if (frameBytes === 0)
-            continue;
-        entry.files = entry.files.filter((f) => !entry.frames.includes(f.name));
-        entry.frames = [];
-        entry.frame_urls = [];
-        entry.frame_durations_ms = [];
-        total -= frameBytes;
-        opts.onNote?.(`replay frames for test ${entry.test_case_id} dropped (upload size cap)`);
-    }
-    // File-count budget: the server parses at most RUN_IMPORT_MAX_FILES multipart
-    // parts, so a big suite's filmstrips can overflow on count with bytes to spare.
-    let fileCount = entries.reduce((n, e) => n + e.files.length, 0);
-    for (const entry of entries) {
-        if (fileCount <= IMPORT_MAX_FILES)
-            break;
-        const frameFiles = entry.files.filter((f) => entry.frames.includes(f.name)).length;
-        if (frameFiles === 0)
-            continue;
-        entry.files = entry.files.filter((f) => !entry.frames.includes(f.name));
-        entry.frames = [];
-        entry.frame_urls = [];
-        entry.frame_durations_ms = [];
-        fileCount -= frameFiles;
-        opts.onNote?.(`replay frames for test ${entry.test_case_id} dropped (upload file-count cap)`);
-    }
-    const manifest = {
-        environment_id: opts.environmentId ?? null,
-        target_url_override: opts.targetUrlOverride ?? null,
-        started_at: opts.startedAt,
-        completed_at: opts.completedAt,
-        results: entries.map(({ files: _files, ...rest }) => rest),
-    };
-    const form = new FormData();
-    form.append("manifest", JSON.stringify(manifest));
-    for (const entry of entries) {
-        for (const file of entry.files) {
-            form.append("files", new Blob([new Uint8Array(file.bytes)]), file.name);
-        }
-    }
-    return form;
-}
-/** Establish (or reuse) an account's proven session server-side — the same establish a
- *  cloud run's setup phase does, so one sign-in serves cloud and local alike. */
-export async function establishAccountSession(client, projectBase, accountId) {
-    let res;
-    try {
-        res = (await client.request("POST", `${projectBase}/test-accounts/${accountId}/session`));
-    }
-    catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-    if (res.ok && res.storage_state) {
-        return {
-            session: {
-                storageState: res.storage_state,
-                initScripts: res.init_scripts ?? [],
-                secrets: res.secrets ?? [],
-            },
-        };
-    }
-    return {
-        error: res.error ?? "SESSION_UNAVAILABLE",
-        unsupported: Boolean(res.unsupported),
-    };
-}
-/**
- * Run one rendered spec on this machine with its full service harness: write the
- * inbox/login sidecars and pump `await_email` requests over the API while Playwright
- * runs. The local-execution seam behind `runs local`. {@link PlaywrightMissingError}
- * propagates (environmental: the caller decides whether to offer an install); any other
- * throw is captured as `runError` (the spec never ran: an errored result, not a crashed
- * command).
- */
-export async function executeLocalSpec(deps, opts) {
-    const { spec } = opts;
-    const inbox = spec.email
-        ? {
-            id: spec.email.inbox_id,
-            address: spec.email.address,
-            recipientContains: spec.email.recipient_contains ?? undefined,
-            // NOW, not the mailbox's creation time: it already holds every earlier run's
-            // mail, and an older code served as this run's would pass the step with a value
-            // the app then rejects. Sent as stored_after, which fences on the server's own
-            // INGESTION time and is clamped server-side — `since` compares against the
-            // sender's Date: header, so a fast local clock would fence out mail that arrived.
-            storedAfter: new Date().toISOString(),
-        }
-        : undefined;
-    try {
-        const outcome = await runSpecLocally({
-            spec: spec.content,
-            testName: spec.title,
-            dir: opts.dir,
-            harvest: opts.harvest,
-            redact: [
-                ...(spec.usesLoginPassword && opts.loginPassword ? [opts.loginPassword] : []),
-                ...(opts.session?.secrets ?? []),
-            ],
-            ...(opts.session
-                ? {
-                    authSession: {
-                        storageState: opts.session.storageState,
-                        initScripts: opts.session.initScripts,
-                    },
-                }
-                : {}),
-            setup: inbox || (spec.usesLoginPassword && opts.loginPassword !== undefined)
-                ? (runDir) => {
-                    if (inbox)
-                        fs.writeFileSync(path.join(runDir, "email-inbox.json"), JSON.stringify({ address: inbox.address }), "utf8");
-                    if (spec.usesLoginPassword && opts.loginPassword !== undefined)
-                        fs.writeFileSync(path.join(runDir, "run-config.json"), JSON.stringify({ login_password: opts.loginPassword }), "utf8");
-                }
-                : undefined,
-            during: (runDir) => {
-                const pump = inbox
-                    ? startEmailPump({
-                        sidecarPath: path.join(runDir, "email-inbox.json"),
-                        client: deps.client,
-                        workspaceId: deps.workspaceId,
-                        inboxId: inbox.id,
-                        storedAfter: inbox.storedAfter,
-                        recipientContains: inbox.recipientContains,
-                        onEvent: opts.onEvent,
-                    })
-                    : undefined;
-                const extra = opts.onSpawn?.(runDir);
-                return () => {
-                    extra?.();
-                    pump?.stop();
-                };
-            },
-        });
-        return { outcome };
-    }
-    catch (err) {
-        if (err instanceof PlaywrightMissingError)
-            throw err;
-        // The spec never ran (compile error, filtered away) — an errored result the
-        // caller records, not an aborted command.
-        return { runError: err instanceof Error ? err.message : String(err) };
-    }
-}

package/dist/local-run.js

@@ -1,340 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { installHint, PLAYWRIGHT_INSTALL_COMMANDS, resolvePlaywrightRunner, } from "./playwright-install.js";
-// @playwright/test is invoked as an external, never bundled — the CLI's zero-runtime-dep rule.
-// The install commands come from playwright-install.ts so hint and installer never drift apart.
-export const PLAYWRIGHT_INSTALL_HINT = "Local Playwright not found. Install it in this project, then re-run:\n" +
-    `  ${PLAYWRIGHT_INSTALL_COMMANDS}`;
-// Isolate the run from any playwright.config.ts in the customer's repo: a stray `testMatch`
-// would exclude our spec (a zero-test run that reads as a false pass), and a `use.baseURL` /
-// `use.storageState` / `globalSetup` there would silently retarget or reauth the run we mean
-// to be a clean local execution of exactly this one spec. `testDir` pins us to our own dir.
-// Reporter is left to the CLI flag + PLAYWRIGHT_JSON_OUTPUT_NAME (as the cloud runner does), so
-// the report lands at exactly our path regardless of what a reporter here would default to.
-const ISOLATING_CONFIG = (testDir, artifactsDir) => `import { defineConfig } from "@playwright/test";\n` +
-    `export default defineConfig({\n` +
-    `  testDir: ${JSON.stringify(testDir)},\n` +
-    `  testMatch: "beryl-local.spec.ts",\n` +
-    `  outputDir: ${JSON.stringify(artifactsDir)},\n` +
-    `  fullyParallel: false,\n` +
-    `});\n`;
-export function scrubText(text, redact) {
-    let out = text;
-    for (const value of redact ?? []) {
-        if (value)
-            out = out.split(value).join("***");
-    }
-    return out;
-}
-export function copyTextScrubbed(src, dest, redact) {
-    if (!redact?.length) {
-        fs.copyFileSync(src, dest);
-        return;
-    }
-    fs.writeFileSync(dest, scrubText(fs.readFileSync(src, "utf8"), redact));
-}
-const PASSING = new Set(["passed", "expected"]);
-const SKIPPED = new Set(["skipped"]);
-export class PlaywrightMissingError extends Error {
-}
-function runProcess(command, args, cwd, env) {
-    return new Promise((resolve) => {
-        const child = spawn(command, args, { cwd, env });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (d) => (stdout += d.toString()));
-        child.stderr.on("data", (d) => (stderr += d.toString()));
-        child.on("error", (err) => resolve({ code: null, stdout, stderr, spawnError: err }));
-        child.on("close", (code) => resolve({ code, stdout, stderr }));
-    });
-}
-// Resolved from the run dir — the exact place the spec imports from — so the process we
-// spawn and the module the spec loads are the same copy. `npx playwright` is the last
-// resort for a CLI install that somehow lost its dependencies.
-export function playwrightBase(runDir) {
-    const runner = resolvePlaywrightRunner(runDir);
-    if (runner?.source === "project") {
-        return { command: process.execPath, args: [runner.cli, "test"], label: "playwright test" };
-    }
-    if (runner) {
-        return {
-            command: process.execPath,
-            args: [runner.cli, "test"],
-            label: "playwright test (bundled with the CLI)",
-            nodePath: path.resolve(path.dirname(runner.cli), "..", ".."),
-        };
-    }
-    const npx = process.platform === "win32" ? "npx.cmd" : "npx";
-    return { command: npx, args: ["playwright", "test"], label: "npx playwright test" };
-}
-// "unknown command 'test'" is the Python `playwright` shim (no `test` subcommand); the module
-// errors mean @playwright/test isn't installed; "Executable doesn't exist" is the runner
-// launching a browser revision that was never downloaded. Either way the actionable answer
-// is the same install hint, not a stack trace.
-function looksLikePlaywrightMissing(r) {
-    if (r.spawnError?.code === "ENOENT")
-        return true;
-    const blob = `${r.stdout}\n${r.stderr}`;
-    return (/unknown command ['"]?test/i.test(blob) ||
-        /Cannot find module ['"]@playwright\/test/i.test(blob) ||
-        /Executable doesn't exist/i.test(blob) ||
-        /npm ERR!.*could not determine executable|npx.*not found/i.test(blob));
-}
-export function parsePlaywrightReport(data) {
-    const results = [];
-    const walk = (suites) => {
-        for (const suite of suites) {
-            for (const spec of suite.specs ?? []) {
-                for (const test of spec.tests ?? []) {
-                    // Last attempt is the verdict — retries can precede it.
-                    const last = test.results?.[test.results.length - 1];
-                    const errors = (last?.errors ?? []).map((e) => e.message).filter(Boolean);
-                    const artifacts = (last?.attachments ?? [])
-                        .map((a) => a.path)
-                        .filter((p) => Boolean(p));
-                    results.push({
-                        name: spec.title ?? "(unnamed)",
-                        status: last?.status ?? "unknown",
-                        duration_ms: last?.duration,
-                        ...(errors.length ? { error: errors.join("\n") } : {}),
-                        artifacts,
-                    });
-                }
-            }
-            if (suite.suites)
-                walk(suite.suites);
-        }
-    };
-    walk(data.suites ?? []);
-    return results;
-}
-// passed/failed exclude skips; an empty set is neither — the caller treats it as a failure
-// because a run that executed nothing is not evidence of a pass.
-export function tally(results) {
-    const passed = results.filter((r) => PASSING.has(r.status)).length;
-    const skipped = results.filter((r) => SKIPPED.has(r.status)).length;
-    return { passed, failed: results.length - passed - skipped };
-}
-function parseReport(reportPath) {
-    return parsePlaywrightReport(JSON.parse(fs.readFileSync(reportPath, "utf8")));
-}
-/** How many filmstrip frames the rendered spec will write — the step total a live
- *  progress bar counts against. 0 when the spec was rendered without frame capture. */
-export function countPlannedFrames(spec) {
-    return spec.match(/frames\/step-\d+\.png/g)?.length ?? 0;
-}
-export function countWrittenFrames(runDir) {
-    try {
-        return fs
-            .readdirSync(path.join(runDir, "frames"))
-            .filter((f) => /^step-\d+\.png$/.test(f)).length;
-    }
-    catch {
-        return 0;
-    }
-}
-const readIfExists = (p) => {
-    try {
-        return fs.readFileSync(p);
-    }
-    catch {
-        return undefined;
-    }
-};
-function findFirstFile(base, test) {
-    let entries;
-    try {
-        entries = fs.readdirSync(base, { withFileTypes: true });
-    }
-    catch {
-        return undefined;
-    }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        const full = path.join(base, entry.name);
-        if (entry.isFile() && test(entry.name))
-            return readIfExists(full);
-        if (entry.isDirectory()) {
-            const nested = findFirstFile(full, test);
-            if (nested)
-                return nested;
-        }
-    }
-    return undefined;
-}
-// Mirrors the cloud runner's workdir harvest (_harvest_frames/_harvest_frame_urls/
-// _harvest_frame_step_durations/_harvest_dom_snapshot/_harvest_phase): the same
-// sorted step-*.png order drives all three frame lists so they stay index-aligned.
-function harvestArtifacts(runDir, artifactsDir) {
-    const framesDir = path.join(runDir, "frames");
-    let framePaths = [];
-    try {
-        framePaths = fs
-            .readdirSync(framesDir)
-            .filter((f) => /^step-\d+\.png$/.test(f))
-            .sort()
-            .map((f) => path.join(framesDir, f));
-    }
-    catch {
-        // no frames dir — spec rendered without capture, or it never got that far
-    }
-    const frames = [];
-    const frameUrls = [];
-    const stamps = [];
-    for (const p of framePaths) {
-        const png = readIfExists(p);
-        if (!png)
-            continue;
-        frames.push(png);
-        frameUrls.push(readIfExists(p.replace(/\.png$/, ".url"))?.toString("utf8").trim() ?? "");
-        const raw = readIfExists(p.replace(/\.png$/, ".ts"))?.toString("utf8").trim();
-        const stamp = raw ? Number(raw) : NaN;
-        stamps.push(Number.isFinite(stamp) ? stamp : null);
-    }
-    const frameDurationsMs = stamps.map((stamp, i) => {
-        if (i === 0)
-            return 0;
-        const prev = stamps[i - 1];
-        return stamp !== null && prev !== null && prev !== undefined
-            ? Math.max(0, stamp - prev)
-            : null;
-    });
-    let phase = "main";
-    try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(runDir, "phase.json"), "utf8"));
-        if (parsed.phase && ["setup", "main", "teardown"].includes(parsed.phase)) {
-            phase = parsed.phase;
-        }
-    }
-    catch {
-        // no phase sidecar — an unsectioned spec
-    }
-    return {
-        frames,
-        frameUrls,
-        frameDurationsMs,
-        screenshot: findFirstFile(artifactsDir, (n) => n.endsWith(".png")),
-        domSnapshot: readIfExists(path.join(runDir, "dom-snapshot.html")),
-        phase,
-    };
-}
-/**
- * Write `spec` next to the caller's project, run it with their local @playwright/test, and
- * parse the JSON report into a structured pass/fail summary. Artifacts + the spec + report land
- * in `dir` when given (kept), otherwise in a temp dir that is cleaned up. Throws
- * {@link PlaywrightMissingError} when no runnable @playwright/test is found so the caller can
- * print an install hint.
- */
-export async function runSpecLocally(opts) {
-    const cwd = process.cwd();
-    // The spec + isolating config MUST sit inside the project tree: Playwright resolves
-    // `@playwright/test` (imported by both) by walking UP from the config file, so a config in
-    // /tmp finds no node_modules and every run dies with "Cannot find module '@playwright/test'".
-    // A run dir under cwd walks up into the project's node_modules; it's always cleaned up.
-    const runDir = fs.mkdtempSync(path.join(cwd, ".beryl-local-"));
-    // The spec's sidecar helpers (__vmInbox/__vmRunConfig) read files via require(),
-    // which dies with "require is not defined" when the surrounding project is
-    // "type": "module" (the spec then compiles as ESM). Scoping the run dir back to
-    // CommonJS matches the cloud workdir; node_modules resolution still walks up.
-    fs.writeFileSync(path.join(runDir, "package.json"), '{"type":"commonjs"}\n');
-    // Where the user-facing outputs (artifacts, spec copy, report) go: --dir if asked, else the
-    // ephemeral run dir.
-    const outDir = opts.dir ? path.resolve(opts.dir) : runDir;
-    fs.mkdirSync(outDir, { recursive: true });
-    let specContent = opts.spec;
-    if (opts.authSession) {
-        // Mirror the cloud runner's staging: write the session files into the workdir and
-        // point the spec's storageState reference at the absolute path (auth-init.json is
-        // read relative to cwd, which is the run dir — same as the cloud workdir).
-        const storagePath = path.join(runDir, "auth-state.json");
-        fs.writeFileSync(storagePath, opts.authSession.storageState, "utf8");
-        fs.writeFileSync(path.join(runDir, "auth-init.json"), JSON.stringify(opts.authSession.initScripts), "utf8");
-        specContent = specContent.split('"auth-state.json"').join(JSON.stringify(storagePath));
-    }
-    const specPath = path.join(runDir, "beryl-local.spec.ts");
-    fs.writeFileSync(specPath, specContent);
-    const configPath = path.join(runDir, "beryl-local.config.ts");
-    const artifactsDir = path.join(outDir, "artifacts");
-    fs.writeFileSync(configPath, ISOLATING_CONFIG(runDir, artifactsDir));
-    const reportPath = path.join(runDir, "report.json");
-    const cleanup = () => fs.rmSync(runDir, { recursive: true, force: true });
-    const { command, args: base, label, nodePath } = playwrightBase(runDir);
-    const args = [...base, `--config=${configPath}`, "--reporter=json"];
-    opts.onProgress?.(`Running ${label} on ${opts.testName}…`);
-    await opts.setup?.(runDir);
-    const stop = opts.during?.(runDir);
-    const env = { ...process.env, PLAYWRIGHT_JSON_OUTPUT_NAME: reportPath };
-    if (nodePath) {
-        env.NODE_PATH = [nodePath, process.env.NODE_PATH].filter(Boolean).join(path.delimiter);
-    }
-    // cwd is the RUN dir, not the project: the spec's relative writes (frames/,
-    // email-inbox.json, dom-snapshot.html, phase.json) must land where we harvest and
-    // clean up, exactly as the cloud runner keys them to its per-run workdir.
-    let result;
-    try {
-        result = await runProcess(command, args, runDir, env);
-    }
-    finally {
-        stop?.();
-    }
-    if (looksLikePlaywrightMissing(result)) {
-        cleanup();
-        throw new PlaywrightMissingError(installHint(cwd));
-    }
-    let results;
-    try {
-        results = parseReport(reportPath);
-    }
-    catch (err) {
-        // No parsable report on a non-zero exit means the spec never ran (compile/launch error) —
-        // surface stderr/stdout so it isn't a silent failure.
-        const detail = (result.stderr || result.stdout || err.message).trim();
-        cleanup();
-        throw new Error(`Playwright produced no readable report — the spec did not run.\n${detail}`);
-    }
-    // A run that executed zero tests is a failure, not a pass — an isolating config matching
-    // exactly our spec should never yield an empty set, so an empty one means the spec was
-    // filtered/skipped away and there is no evidence it ran.
-    if (results.length === 0) {
-        const detail = (result.stderr || result.stdout || "no tests were run").trim();
-        cleanup();
-        throw new Error(`Playwright ran no tests from the rendered spec.\n${detail}`);
-    }
-    const harvested = opts.harvest ? harvestArtifacts(runDir, artifactsDir) : undefined;
-    let keptSpec = specPath;
-    let keptReport = reportPath;
-    if (opts.dir) {
-        // Persist the exact spec + report next to the artifacts before the run dir is removed,
-        // plus the spec's relative writes (filmstrip frames, failure DOM) that live in it.
-        // Text files are scrubbed like the uploaded bytes; frames are pixels.
-        keptSpec = path.join(outDir, "beryl-local.spec.ts");
-        keptReport = path.join(outDir, "report.json");
-        fs.copyFileSync(specPath, keptSpec);
-        copyTextScrubbed(reportPath, keptReport, opts.redact);
-        const framesSrc = path.join(runDir, "frames");
-        if (fs.existsSync(framesSrc) && framesSrc !== path.join(outDir, "frames")) {
-            fs.cpSync(framesSrc, path.join(outDir, "frames"), { recursive: true, force: true });
-        }
-        const domSrc = path.join(runDir, "dom-snapshot.html");
-        if (fs.existsSync(domSrc) && domSrc !== path.join(outDir, "dom-snapshot.html")) {
-            copyTextScrubbed(domSrc, path.join(outDir, "dom-snapshot.html"), opts.redact);
-        }
-    }
-    else {
-        // Without --dir the artifacts lived in the run dir we're about to delete, so their paths
-        // would dangle — don't hand back paths to files that no longer exist.
-        for (const r of results)
-            r.artifacts = [];
-    }
-    cleanup();
-    const { passed, failed } = tally(results);
-    return {
-        passed,
-        failed,
-        results,
-        directory: outDir,
-        spec: keptSpec,
-        report: keptReport,
-        ...(harvested ? { harvested } : {}),
-    };
-}