@useblacksmith/vitest 0.0.0-stage → 0.2.1

package/dist/cache.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Keeps the dependency record and tree anchor in the Actions cache from
+ * inside the run, so a job needs no restore/save steps. Speaks the cache
+ * service's twirp API at ACTIONS_RESULTS_URL; on a Blacksmith runner a plain
+ * step can reach it with no token because the VM proxy adds one, elsewhere
+ * the variable is absent and nothing happens. Every failure here is logged
+ * once and never changes the run.
+ */
+export declare const ENV_CACHE_URL = "ACTIONS_RESULTS_URL";
+/** Bundle format; bumped when its shape changes so old entries are missed, not misread. */
+export declare const BUNDLE_VERSION = "blacksmith-vitest-bundle-1";
+export declare const TIMEOUT_MS = 15000;
+/** Files under the cache dir that travel in the bundle. */
+export declare const RECORD_FILE: RegExp;
+export interface CacheKey {
+    /** Exact key for this tree; also the save key. */
+    key: string;
+    /** Prefix shared by every entry for the same shard and project set: the newest one restores. */
+    prefix: string;
+}
+export declare const DEFAULT_CACHE_PREFIX = "blacksmith-vitest";
+export declare function cacheKey(input: {
+    snapshotVersion: number;
+    projects: string[];
+    shard: {
+        index: number;
+        count: number;
+    } | null;
+    head: string;
+}): CacheKey;
+export type RestoreOutcome = {
+    restored: true;
+    key: string;
+    files: number;
+} | {
+    restored: false;
+    reason: string;
+};
+/** Fetches the newest bundle under `prefix` (exact `key` first) into `cacheDir`. */
+export declare function restoreBundle(base: string, cacheDir: string, { key, prefix }: CacheKey): Promise<RestoreOutcome>;
+export type SaveOutcome = {
+    saved: true;
+    bytes: number;
+} | {
+    saved: false;
+    reason: string;
+};
+/** Uploads the record and anchors under the exact `key`; an existing entry for that key is left alone. */
+export declare function saveBundle(base: string, cacheDir: string, { key }: CacheKey): Promise<SaveOutcome>;

package/dist/cache.js

@@ -0,0 +1,125 @@
+import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { gunzipSync, gzipSync } from 'node:zlib';
+/**
+ * Keeps the dependency record and tree anchor in the Actions cache from
+ * inside the run, so a job needs no restore/save steps. Speaks the cache
+ * service's twirp API at ACTIONS_RESULTS_URL; on a Blacksmith runner a plain
+ * step can reach it with no token because the VM proxy adds one, elsewhere
+ * the variable is absent and nothing happens. Every failure here is logged
+ * once and never changes the run.
+ */
+export const ENV_CACHE_URL = 'ACTIONS_RESULTS_URL';
+const TWIRP = 'twirp/github.actions.results.api.v1.CacheService/';
+/** Bundle format; bumped when its shape changes so old entries are missed, not misread. */
+export const BUNDLE_VERSION = 'blacksmith-vitest-bundle-1';
+export const TIMEOUT_MS = 15_000;
+/** Files under the cache dir that travel in the bundle. */
+export const RECORD_FILE = /^(dependencies\.json|blacksmith(\.[0-9a-f]{12})?\.json)$/;
+export const DEFAULT_CACHE_PREFIX = 'blacksmith-vitest';
+export function cacheKey(input) {
+    const scope = [
+        `v${input.snapshotVersion}`,
+        input.projects.some(Boolean)
+            ? createHash('sha1')
+                .update(input.projects.join('\n'))
+                .digest('hex')
+                .slice(0, 12)
+            : 'all',
+        input.shard ? `${input.shard.index}of${input.shard.count}` : '1of1',
+    ].join('-');
+    const prefix = `${DEFAULT_CACHE_PREFIX}-${scope}-`;
+    return { key: `${prefix}${input.head}`, prefix };
+}
+async function twirp(base, method, body) {
+    const response = await fetch(new URL(TWIRP + method, base), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'user-agent': '@useblacksmith/vitest',
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`${method} ${response.status}`);
+    return (await response.json());
+}
+/**
+ * Requests carry both casings: a twirp JSON server accepts proto field names
+ * (`restore_keys`, `size_bytes` as an integer) and their lowerCamel aliases;
+ * the Blacksmith cache service validates the former and answers in it.
+ */
+function field(record, snake, camel) {
+    return record[snake] ?? record[camel];
+}
+/** Fetches the newest bundle under `prefix` (exact `key` first) into `cacheDir`. */
+export async function restoreBundle(base, cacheDir, { key, prefix }) {
+    const lookup = await twirp(base, 'GetCacheEntryDownloadURL', {
+        key,
+        restore_keys: [prefix],
+        restoreKeys: [prefix],
+        version: BUNDLE_VERSION,
+    });
+    const url = field(lookup, 'signed_download_url', 'signedDownloadUrl');
+    if (!lookup.ok || typeof url !== 'string' || url === '') {
+        return { restored: false, reason: `no entry under ${prefix}` };
+    }
+    const response = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!response.ok)
+        throw new Error(`download ${response.status}`);
+    const bundle = JSON.parse(gunzipSync(Buffer.from(await response.arrayBuffer())).toString('utf8'));
+    if (bundle.version !== BUNDLE_VERSION) {
+        return { restored: false, reason: `bundle version ${bundle.version}` };
+    }
+    await mkdir(cacheDir, { recursive: true });
+    for (const [name, content] of Object.entries(bundle.files)) {
+        if (!RECORD_FILE.test(name))
+            continue;
+        await writeFile(path.join(cacheDir, name), content);
+    }
+    const matched = field(lookup, 'matched_key', 'matchedKey');
+    return {
+        restored: true,
+        key: typeof matched === 'string' && matched !== '' ? matched : key,
+        files: Object.keys(bundle.files).length,
+    };
+}
+/** Uploads the record and anchors under the exact `key`; an existing entry for that key is left alone. */
+export async function saveBundle(base, cacheDir, { key }) {
+    const files = {};
+    for (const name of await readdir(cacheDir)) {
+        if (RECORD_FILE.test(name))
+            files[name] = await readFile(path.join(cacheDir, name), 'utf8');
+    }
+    const body = gzipSync(JSON.stringify({ version: BUNDLE_VERSION, files }));
+    const reserve = await twirp(base, 'CreateCacheEntry', {
+        key,
+        version: BUNDLE_VERSION,
+    });
+    const url = field(reserve, 'signed_upload_url', 'signedUploadUrl');
+    if (!reserve.ok || typeof url !== 'string' || url === '') {
+        return { saved: false, reason: `${key} already exists or was refused` };
+    }
+    const put = await fetch(url, {
+        method: 'PUT',
+        headers: {
+            'x-ms-blob-type': 'BlockBlob',
+            'content-type': 'application/octet-stream',
+        },
+        body,
+        signal: AbortSignal.timeout(TIMEOUT_MS * 4),
+    });
+    if (!put.ok)
+        throw new Error(`upload ${put.status}`);
+    const done = await twirp(base, 'FinalizeCacheEntryUpload', {
+        key,
+        version: BUNDLE_VERSION,
+        size_bytes: body.byteLength,
+        sizeBytes: String(body.byteLength),
+    });
+    if (!done.ok)
+        return { saved: false, reason: `finalize refused ${key}` };
+    return { saved: true, bytes: body.byteLength };
+}

package/dist/git.d.ts

@@ -0,0 +1,21 @@
+/** Repository-relative path → `<mode> <sha>` (see `anchorTree`), so a chmod is a change. */
+export type Tree = Record<string, string>;
+export declare function repoRoot(cwd: string): Promise<string>;
+export declare function headSha(repo: string): Promise<string>;
+/** Lockfiles anywhere in the worktree, tracked or not. */
+export declare function lockfilePaths(repo: string, names: Iterable<string>): Promise<string[]>;
+/** Every path git would show for the worktree: tracked and untracked, not ignored. */
+export declare function knownPaths(repo: string): Promise<Set<string>>;
+/**
+ * What each path looks like now: a file is `<mode> <blob>` as `git ls-tree`
+ * prints it, a symlink hashes its target, a directory hashes its listing (every
+ * tracked or untracked non-ignored path under it, so an entry moving in, out or
+ * within changes it; an edit to one does not), a submodule stands by its
+ * commit. Ignored files and paths that do not exist get no entry, the same
+ * absence as before they appeared.
+ *
+ * e.g. `['src/a.ts', 'fixtures']` → `{ 'src/a.ts': '100644 3b18e5…', fixtures: '040000 9f2c…' }`
+ */
+export declare function anchorTree(repo: string, paths: Iterable<string>): Promise<Tree>;
+/** Paths whose blob differs between the trees, including files only present in one of them. */
+export declare function diffTrees(before: Tree, after: Tree): string[];

package/dist/git.js

@@ -0,0 +1,225 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { lstatSync, readlinkSync } from 'node:fs';
+import path from 'node:path';
+function git(cwd, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, {
+            cwd,
+            stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout?.on('data', (chunk) => stdout.push(chunk));
+        child.stderr?.on('data', (chunk) => stderr.push(chunk));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve(Buffer.concat(stdout).toString('utf8'));
+            else {
+                reject(new Error(`git ${args.join(' ')} exited with ${code}: ${Buffer.concat(stderr).toString('utf8').trim()}`));
+            }
+        });
+        if (input !== undefined) {
+            child.stdin?.on('error', reject);
+            child.stdin?.end(input);
+        }
+    });
+}
+export async function repoRoot(cwd) {
+    return (await git(cwd, ['rev-parse', '--show-toplevel'])).trim();
+}
+export async function headSha(repo) {
+    return (await git(repo, ['rev-parse', 'HEAD'])).trim();
+}
+/** A dirty submodule is the only directory `git ls-files` names itself; its checked-out commit stands in for a blob sha. */
+async function submoduleHead(repo, dir) {
+    try {
+        return `160000 ${(await git(path.join(repo, dir), ['rev-parse', 'HEAD'])).trim()}`;
+    }
+    catch {
+        return `160000 dirty:${dir}`;
+    }
+}
+/** False where git ignores the executable bit (`core.fileMode`, e.g. FAT or Windows); a file then keeps the mode the index has for it. */
+async function tracksFileMode(repo) {
+    try {
+        const value = await git(repo, ['config', '--type=bool', 'core.fileMode']);
+        return value.trim() !== 'false';
+    }
+    catch {
+        return true;
+    }
+}
+/** Lockfiles anywhere in the worktree, tracked or not. */
+export function lockfilePaths(repo, names) {
+    return listKnown(repo, [...names].map((name) => `:(glob)**/${name}`), false).then((known) => [...known].sort());
+}
+/** Every path git would show for the worktree: tracked and untracked, not ignored. */
+export function knownPaths(repo) {
+    return listKnown(repo, ['.'], false);
+}
+/**
+ * Paths git would show for the pathspecs: tracked files still on disk and
+ * untracked files not ignored, so a directory's listing is what `git status`
+ * would attribute to it. Index entries whose file is gone are left out.
+ */
+async function listKnown(repo, pathspecs, literal = true) {
+    const known = new Set();
+    const gone = new Set();
+    for (let i = 0; i < pathspecs.length; i += 500) {
+        const output = await git(repo, [
+            ...(literal ? ['--literal-pathspecs'] : []),
+            'ls-files',
+            '-z',
+            '-t',
+            '--cached',
+            '--others',
+            '--deleted',
+            '--exclude-standard',
+            '--',
+            ...pathspecs.slice(i, i + 500),
+        ]);
+        for (const entry of output.split('\0')) {
+            if (entry === '')
+                continue;
+            const file = entry.slice(2);
+            if (entry[0] === 'R')
+                gone.add(file);
+            else
+                known.add(file);
+        }
+    }
+    for (const file of gone)
+        known.delete(file);
+    return known;
+}
+/** Entries of `sorted` under `dir/`, by binary search for the prefix. */
+function under(sorted, dir) {
+    const prefix = `${dir}/`;
+    let low = 0;
+    let high = sorted.length;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        if ((sorted[mid] ?? '') < prefix)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    const listing = [];
+    for (let i = low; i < sorted.length; i++) {
+        const entry = sorted[i] ?? '';
+        if (!entry.startsWith(prefix))
+            break;
+        listing.push(entry);
+    }
+    return listing;
+}
+const DIRECTORY_MODE = '040000';
+/**
+ * What each path looks like now: a file is `<mode> <blob>` as `git ls-tree`
+ * prints it, a symlink hashes its target, a directory hashes its listing (every
+ * tracked or untracked non-ignored path under it, so an entry moving in, out or
+ * within changes it; an edit to one does not), a submodule stands by its
+ * commit. Ignored files and paths that do not exist get no entry, the same
+ * absence as before they appeared.
+ *
+ * e.g. `['src/a.ts', 'fixtures']` → `{ 'src/a.ts': '100644 3b18e5…', fixtures: '040000 9f2c…' }`
+ */
+export async function anchorTree(repo, paths) {
+    const wanted = [...new Set(paths)]
+        .filter((file) => file !== '' &&
+        file !== '.' &&
+        file !== '..' &&
+        !file.startsWith('../') &&
+        !path.isAbsolute(file))
+        .sort();
+    const tree = {};
+    if (wanted.length === 0)
+        return tree;
+    const present = new Map();
+    for (const file of wanted) {
+        const stat = lstatSync(path.join(repo, file), { throwIfNoEntry: false });
+        if (stat !== undefined)
+            present.set(file, stat);
+    }
+    // Directories apart from files: a directory pathspec walks its contents, a
+    // file pathspec is a lookup, and a chunk mixing them pays the walk for all.
+    const dirs = [];
+    const others = [];
+    for (const [file, stat] of present)
+        (stat.isDirectory() ? dirs : others).push(file);
+    const known = await listKnown(repo, dirs);
+    for (const file of await listKnown(repo, others))
+        known.add(file);
+    const sorted = [...known].sort();
+    const files = [];
+    const modes = [];
+    let fileMode;
+    for (const [file, stat] of present) {
+        if (stat.isDirectory()) {
+            tree[file] = known.has(file)
+                ? await submoduleHead(repo, file)
+                : `${DIRECTORY_MODE} ${createHash('sha1').update(under(sorted, file).join('\0')).digest('hex')}`;
+        }
+        else if (!known.has(file))
+            continue;
+        else if (stat.isSymbolicLink()) {
+            const target = readlinkSync(path.join(repo, file));
+            const sha = (await git(repo, ['hash-object', '--stdin'], target)).trim();
+            tree[file] = `120000 ${sha}`;
+        }
+        else {
+            files.push(file);
+            fileMode ??= await tracksFileMode(repo);
+            modes.push(!fileMode ? '' : stat.mode & 0o111 ? '100755' : '100644');
+        }
+    }
+    if (files.length === 0)
+        return tree;
+    if (fileMode === false) {
+        const indexModes = new Map();
+        for (let i = 0; i < files.length; i += 500) {
+            const staged = await git(repo, [
+                '--literal-pathspecs',
+                'ls-files',
+                '-z',
+                '--stage',
+                '--',
+                ...files.slice(i, i + 500),
+            ]);
+            for (const entry of staged.split('\0')) {
+                const tab = entry.indexOf('\t');
+                if (tab === -1)
+                    continue;
+                indexModes.set(entry.slice(tab + 1), entry.slice(0, 6));
+            }
+        }
+        files.forEach((file, index) => {
+            modes[index] = indexModes.get(file) ?? '100644';
+        });
+    }
+    const shas = (await git(repo, ['hash-object', '--stdin-paths'], files.join('\n')))
+        .trim()
+        .split('\n');
+    files.forEach((file, index) => {
+        const sha = shas[index];
+        if (sha === undefined)
+            throw new Error(`git hash-object returned no sha for ${file}`);
+        tree[file] = `${modes[index]} ${sha}`;
+    });
+    return tree;
+}
+/** Paths whose blob differs between the trees, including files only present in one of them. */
+export function diffTrees(before, after) {
+    const changed = [];
+    for (const [file, sha] of Object.entries(after)) {
+        if (before[file] !== sha)
+            changed.push(file);
+    }
+    for (const file of Object.keys(before)) {
+        if (!(file in after))
+            changed.push(file);
+    }
+    return changed;
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { Plugin } from 'vitest/config';
+export { BlacksmithReporter } from './reporter.js';
+export { HashShardSequencer, shardFor } from './sequencer.js';
+export { ShadowAnalysis, type ShadowResult, SNAPSHOT_FILE, type Snapshot, } from './affected.js';
+export type { Payload, RunError, TestResultRecord, TestStatus, } from './payload.js';
+export interface BlacksmithOptions {
+    /**
+     * Run every test instead of only those affected since the last green run.
+     * By default (false) the plugin turns `--changed` on itself, provided the
+     * running Vitest routes it through the plugin's VCS provider and records
+     * dependencies; otherwise it warns once and every test runs, so an older
+     * Vitest never skips tests on a stale record.
+     */
+    runAllTests?: boolean;
+    /**
+     * Run every test and only *report* what the affected selection would have
+     * run: vitest records dependencies but gets no `--changed` and no VCS
+     * provider, the shard's cached record is fetched into a temporary directory
+     * (vitest's `cacheDir` is left alone) and, when the run ends, the plugin
+     * logs how many of the files that ran it would have selected and which
+     * failing test files it would have skipped. A green run still saves the record.
+     */
+    shadow?: boolean;
+    /**
+     * Dependencies the tracking cannot see (files a test reads through a child
+     * process, in `globalSetup`, or outside node): globs of test files mapped
+     * to the glob(s) of the files they depend on, both relative to the config
+     * root. A change to a matching file reruns every test file the key matches.
+     * `{ 'tests/*.spec.ts': 'fixtures/**' }`, say.
+     */
+    dependencies?: Record<string, string | string[]>;
+}
+export default function blacksmith(options?: BlacksmithOptions): Plugin;

package/dist/index.js

@@ -0,0 +1,92 @@
+import { fileURLToPath } from 'node:url';
+import { compileDependencies, configuredProvider, isTreeSnapshotProvider, isSnapshotRecorder, restoreDependencyCache, ShadowAnalysis, SnapshotRecorder, TreeSnapshotProvider, } from './affected.js';
+import { customSequencer, HashShardSequencer, stableShards, } from './sequencer.js';
+export { BlacksmithReporter } from './reporter.js';
+export { HashShardSequencer, shardFor } from './sequencer.js';
+export { ShadowAnalysis, SNAPSHOT_FILE, } from './affected.js';
+/** Beside this module; `.ts` when the plugin runs from source (its own test fixtures). */
+const recordReads = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './record-reads.ts' : './record-reads.js', import.meta.url));
+/** Whether this Vitest wired up the pieces `--changed` selection relies on. */
+function supportsChanged(vitest) {
+    const { vcs } = vitest;
+    const experimental = vitest.config.experimental;
+    return (typeof vcs?.findChangedFiles === 'function' &&
+        experimental?.recordDependencies === true &&
+        isTreeSnapshotProvider(experimental.vcsProvider));
+}
+export default function blacksmith(options = {}) {
+    const provider = new TreeSnapshotProvider();
+    provider.dependencies = compileDependencies(options.dependencies);
+    let changedApplied = false;
+    let restored;
+    let shadow;
+    return {
+        name: 'blacksmith',
+        config(userConfig) {
+            // Vite merges this over the user's config, so a sequencer the config
+            // names is kept; `configureVitest` pins its shard assignment.
+            const theirs = customSequencer(userConfig.test
+                ?.sequence?.sequencer);
+            return {
+                test: {
+                    experimental: options.shadow
+                        ? { recordDependencies: true }
+                        : { recordDependencies: true, vcsProvider: provider },
+                    ...(theirs ? {} : { sequence: { sequencer: HashShardSequencer } }),
+                },
+            };
+        },
+        async configureVitest({ vitest, project }) {
+            // Vitest loads the root config's provider. A project with its own
+            // `root` re-evaluates this config file, so this hook may run from a
+            // second plugin instance; configure the provider vitest actually uses.
+            const active = configuredProvider(vitest) ?? provider;
+            active.vitest = vitest;
+            active.dependencies = provider.dependencies;
+            // Their sequencer's shards must not depend on which tests the
+            // selection kept, or the provider's view of the shard and vitest's
+            // would differ.
+            if (customSequencer(vitest.config.sequence.sequencer)) {
+                vitest.config.sequence.sequencer = stableShards(vitest.config.sequence.sequencer);
+            }
+            if (options.shadow) {
+                if (vitest.config.changed) {
+                    vitest.logger.warn('[blacksmith] shadow mode runs every test; ignoring --changed');
+                    vitest.config.changed = false;
+                }
+                shadow ??= new ShadowAnalysis(vitest, active.dependencies);
+            }
+            else {
+                restored ??= restoreDependencyCache(vitest);
+                await restored;
+            }
+            if (!options.shadow &&
+                !options.runAllTests &&
+                !vitest.config.changed &&
+                !changedApplied) {
+                changedApplied = true;
+                if (supportsChanged(vitest)) {
+                    vitest.config.changed = true;
+                    // An empty selection is the success case here, not a misconfigured run.
+                    vitest.config.passWithNoTests = true;
+                }
+                else {
+                    vitest.logger.warn('[blacksmith] This vitest version does not support running changed tests with Blacksmith');
+                }
+            }
+            // Per project, since a project's own `setupFiles` replace the root's;
+            // first, so reads by those setup files are recorded too. A browser
+            // project has no `node:fs` to wrap.
+            if (!project.isBrowserEnabled()) {
+                project.config.setupFiles = [
+                    recordReads,
+                    ...project.config.setupFiles.filter((file) => file !== recordReads),
+                ];
+            }
+            const reporters = vitest.config.reporters;
+            if (!reporters.some(isSnapshotRecorder)) {
+                reporters.push(new SnapshotRecorder(active, { shadow }));
+            }
+        },
+    };
+}

package/dist/payload.d.ts

@@ -0,0 +1,56 @@
+export type TestStatus = 'passed' | 'failed' | 'skipped';
+export interface TestError {
+    message: string;
+    stack: string;
+}
+export interface TestResultRecord {
+    /** Test file, relative to the repository when the run is inside GITHUB_WORKSPACE */
+    file: string;
+    /** Vitest project the test ran in; null for the root project */
+    project: string | null;
+    /** Enclosing describe blocks, outermost first */
+    suite: string[];
+    name: string;
+    status: TestStatus;
+    /** null for tests that never ran (skipped, todo) */
+    duration_ms: number | null;
+    started_at: string | null;
+    retries: number;
+    flaky: boolean;
+    error?: TestError;
+}
+/** A failure outside any test: a module that threw while being imported or collected, or an unhandled error */
+export interface RunError {
+    /** null when the error is not attributable to a test file */
+    file: string | null;
+    message: string;
+    stack: string;
+}
+export interface Payload {
+    framework: 'vitest';
+    framework_version: string;
+    reporter_version: string;
+    run: {
+        started_at: string;
+        finished_at: string;
+        reason: 'passed' | 'failed' | 'interrupted';
+    };
+    results: TestResultRecord[];
+    errors: RunError[];
+    /** true when results or errors beyond the count or byte caps were dropped */
+    truncated: boolean;
+}
+export declare const MAX_RESULTS = 50000;
+export declare const MAX_PAYLOAD_BYTES: number;
+export declare const MAX_ERROR_MESSAGE_CHARS = 4096;
+export declare const MAX_ERROR_STACK_CHARS = 16384;
+export declare function truncate(text: string, max: number): string;
+/**
+ * Keeps results in order until either cap is hit, then errors in whatever
+ * budget is left, so a payload never serializes past MAX_PAYLOAD_BYTES of
+ * JSON (the gzip input, which is also the backend's memory ceiling).
+ */
+export declare function buildPayload(results: TestResultRecord[], errors: RunError[], run: Payload['run'], versions: {
+    framework: string;
+    reporter: string;
+}, maxBytes?: number): Payload;

package/dist/payload.js

@@ -0,0 +1,40 @@
+export const MAX_RESULTS = 50_000;
+export const MAX_PAYLOAD_BYTES = 32 * 1024 * 1024;
+export const MAX_ERROR_MESSAGE_CHARS = 4_096;
+export const MAX_ERROR_STACK_CHARS = 16_384;
+export function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/**
+ * Keeps results in order until either cap is hit, then errors in whatever
+ * budget is left, so a payload never serializes past MAX_PAYLOAD_BYTES of
+ * JSON (the gzip input, which is also the backend's memory ceiling).
+ */
+export function buildPayload(results, errors, run, versions, maxBytes = MAX_PAYLOAD_BYTES) {
+    let bytes = 0;
+    let truncated = false;
+    const keep = (items, max) => {
+        const kept = [];
+        for (const item of items) {
+            const size = JSON.stringify(item).length + 1;
+            if (kept.length >= max || bytes + size > maxBytes) {
+                truncated = true;
+                break;
+            }
+            bytes += size;
+            kept.push(item);
+        }
+        return kept;
+    };
+    const keptResults = keep(results, MAX_RESULTS);
+    const keptErrors = keep(errors, MAX_RESULTS);
+    return {
+        framework: 'vitest',
+        framework_version: versions.framework,
+        reporter_version: versions.reporter,
+        run,
+        results: keptResults,
+        errors: keptErrors,
+        truncated,
+    };
+}

package/dist/record-reads.d.ts

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