Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Publish immutable Vite seed generations (#7508)

Nick Gomeza6d1286021f6
diff --git a/packages/app/tests/meta/vite-seed-pointer.test.ts b/packages/app/tests/meta/vite-seed-pointer.test.ts
new file mode 100644
index 000000000..b7b8d4155
--- /dev/null
+++ b/packages/app/tests/meta/vite-seed-pointer.test.ts
@@ -0,0 +1,82 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { describe, expect, test, vi } from 'vitest';
+import { APP_PACKAGE_ROOT } from '../stress/_helpers/server-process.ts';
+import { withTempDir } from '../temp-dir.test-helper.ts';
+
+const TEMP_DIR_PREFIX = 'ok-vite-seed-pointer-';
+
+async function serverProcessFor(seedDir: string) {
+ vi.stubEnv('OK_TEST_VITE_SEED_DIR', seedDir);
+ vi.resetModules();
+ try {
+ return await import('../stress/_helpers/server-process.ts');
+ } finally {
+ vi.unstubAllEnvs();
+ vi.resetModules();
+ }
+}
+
+async function seedResolverFor(seedDir: string) {
+ return (await serverProcessFor(seedDir)).resolveViteSeedDir;
+}
+
+describe('vite seed pointer resolution', () => {
+ test('a published pointer names the generation workers copy', async () => {
+ await withTempDir(TEMP_DIR_PREFIX, async (dir) => {
+ const seedDir = join(dir, 'seed');
+ const published = join(dir, 'published-generation');
+ mkdirSync(published);
+ writeFileSync(`${seedDir}.current`, `${published}\n`);
+ const resolveSeed = await seedResolverFor(seedDir);
+ expect(resolveSeed()).toBe(published);
+ });
+ });
+
+ test('without a pointer, the legacy seed directory is used when it exists and nothing otherwise', async () => {
+ await withTempDir(TEMP_DIR_PREFIX, async (dir) => {
+ const seedDir = join(dir, 'seed');
+ const resolveSeed = await seedResolverFor(seedDir);
+ expect(resolveSeed()).toBeUndefined();
+ mkdirSync(seedDir);
+ expect(resolveSeed()).toBe(seedDir);
+ });
+ });
+
+ test('a pointer that exists but cannot be read is reported with its path and errno', async () => {
+ await withTempDir(TEMP_DIR_PREFIX, async (dir) => {
+ const seedDir = join(dir, 'seed');
+ const pointer = `${seedDir}.current`;
+ mkdirSync(pointer);
+ const resolveSeed = await seedResolverFor(seedDir);
+ expect(() => resolveSeed()).toThrow(pointer);
+ expect(() => resolveSeed()).toThrow('EISDIR');
+ });
+ });
+
+ test('a pointer that cannot be read fails cache preparation and leaves no cache directory behind', async ({
+ onTestFinished,
+ }) => {
+ await withTempDir(TEMP_DIR_PREFIX, async (dir) => {
+ const seedDir = join(dir, 'seed');
+ const pointer = `${seedDir}.current`;
+ const { prepareViteCacheDir } = await serverProcessFor(seedDir);
+ const cacheParent = join(APP_PACKAGE_ROOT, 'node_modules');
+ const prefix = `unreadable-pointer-${randomUUID()}`;
+ const prepared = () =>
+ readdirSync(cacheParent).filter((name) => name.startsWith(`.vite-${prefix}-`));
+ onTestFinished(() => {
+ for (const name of prepared()) {
+ rmSync(join(cacheParent, name), { recursive: true, force: true });
+ }
+ });
+ const control = basename(prepareViteCacheDir(prefix));
+ expect(prepared()).toEqual([control]);
+
+ mkdirSync(pointer);
+ expect(() => prepareViteCacheDir(prefix)).toThrow(pointer);
+ expect(prepared()).toEqual([control]);
+ });
+ });
+});
diff --git a/packages/app/tests/meta/vite-seed-publication.reads.ts b/packages/app/tests/meta/vite-seed-publication.reads.ts
new file mode 100644
index 000000000..0e709b068
--- /dev/null
+++ b/packages/app/tests/meta/vite-seed-publication.reads.ts
@@ -0,0 +1,14 @@
+export const ROUND_READS = {
+ test: './vite-seed-publication.test.ts',
+ reads:
+ 'the warm-seed race harness, the stress helpers it runs and the owner lifeline it runs under, then what its two warm builds read: the app, core and server packages the Vite dev server loads, the test-support modules its child processes load, the lockfile, the project config and the root package.json',
+ include: [
+ 'packages/app/**',
+ 'packages/core/**',
+ 'packages/server/**',
+ 'test-support/**',
+ 'pnpm-lock.yaml',
+ '.ok/config.yml',
+ 'package.json',
+ ],
+};
diff --git a/packages/app/tests/meta/vite-seed-publication.test.ts b/packages/app/tests/meta/vite-seed-publication.test.ts
new file mode 100644
index 000000000..1be687dbb
--- /dev/null
+++ b/packages/app/tests/meta/vite-seed-publication.test.ts
@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from 'vitest';
+import { spawnUnderOwnerLifeline } from '../../../../test-support/owner-lifeline.ts';
+import { APP_PACKAGE_ROOT } from '../stress/_helpers/seed-key.ts';
+import { removeRaceArtifacts } from '../stress/_helpers/vite-seed-race/race-artifacts.ts';
+
+const REPRODUCTION = fileURLToPath(
+ new URL('../stress/_helpers/vite-seed-race/reproduce.mjs', import.meta.url),
+);
+
+test('warm seed publication keeps a concurrent worker copyable', {
+ timeout: 180_000,
+}, async ({ signal, onTestFinished, onTestFailed }) => {
+ const runDir = mkdtempSync(join(tmpdir(), 'ok-vite-warm-race-'));
+ const consumerCacheToken = randomUUID();
+ const { child, commandResult } = spawnUnderOwnerLifeline('pnpm', ['exec', 'tsx', REPRODUCTION], {
+ cwd: APP_PACKAGE_ROOT,
+ env: {
+ ...process.env,
+ VITE_RACE_RUN_DIR: runDir,
+ VITE_RACE_CONSUMER_CACHE_TOKEN: consumerCacheToken,
+ },
+ });
+ let stdout = '';
+ let stderr = '';
+ child.stdout.setEncoding('utf8').on('data', (chunk: string) => {
+ stdout += chunk;
+ });
+ child.stderr.setEncoding('utf8').on('data', (chunk: string) => {
+ stderr += chunk;
+ });
+ const closed = new Promise<void>((resolve) => {
+ child.once('close', () => resolve());
+ });
+ const exited = new Promise<void>((resolve, reject) => {
+ child.once('error', reject);
+ closed.then(resolve);
+ });
+ let treeEnded: Promise<void> | undefined;
+ const endTree = () => {
+ if (treeEnded === undefined) {
+ child.stdin.end();
+ treeEnded = closed;
+ }
+ return treeEnded;
+ };
+ signal.addEventListener('abort', endTree, { once: true });
+ onTestFinished(async () => {
+ await endTree();
+ const failures = removeRaceArtifacts({ runDir, consumerCacheToken });
+ if (failures.length > 0) {
+ throw new Error(
+ `The warm seed race reproduction left artifacts it could not remove:\n${failures.join('\n')}`,
+ );
+ }
+ });
+ onTestFailed(() => {
+ throw new Error(
+ `The warm seed race reproduction's streams.\n--- stdout ---\n${stdout}\n--- stderr ---\n${stderr}`,
+ );
+ });
+
+ const [result] = await Promise.all([commandResult, exited]);
+ expect(result, 'reproduce.mjs must exit on its own with code 0').toEqual({
+ code: 0,
+ signal: null,
+ });
+ expect(JSON.parse(stdout)).toMatchObject({
+ consumerResult: { status: 'passed', copiedMetadata: true },
+ producerResult: { status: 'passed' },
+ producerPublished: true,
+ consumerCopyDone: true,
+ });
+});
diff --git a/packages/app/tests/meta/vite-seed-race-cache-token.test.ts b/packages/app/tests/meta/vite-seed-race-cache-token.test.ts
new file mode 100644
index 000000000..d6bd4d2e2
--- /dev/null
+++ b/packages/app/tests/meta/vite-seed-race-cache-token.test.ts
@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, test, vi } from 'vitest';
+import { withTempDir } from '../temp-dir.test-helper.ts';
+
+const TEMP_DIR_PREFIX = 'ok-vite-race-cache-token-';
+const INSTALLED = ['.vite-e2e-seed', 'react', 'vite'];
+const BLANK_TOKENS = ['', ' \t '];
+
+function installedCacheParent(appRoot: string): string {
+ const parent = join(appRoot, 'node_modules');
+ for (const name of INSTALLED) mkdirSync(join(parent, name), { recursive: true });
+ return parent;
+}
+
+function plantedRunCopy(parent: string): string {
+ const token = randomUUID();
+ mkdirSync(join(parent, `.vite-race-${token}-copy`));
+ return token;
+}
+
+function redirectAppRoot(appRoot: string): void {
+ vi.doMock('../stress/_helpers/seed-key.ts', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('../stress/_helpers/seed-key.ts')>()),
+ APP_PACKAGE_ROOT: appRoot,
+ }));
+}
+
+async function raceArtifactsUnder(appRoot: string) {
+ vi.resetModules();
+ redirectAppRoot(appRoot);
+ try {
+ return (await import('../stress/_helpers/vite-seed-race/race-artifacts.ts'))
+ .removeRaceArtifacts;
+ } finally {
+ vi.doUnmock('../stress/_helpers/seed-key.ts');
+ vi.resetModules();
+ }
+}
+
+function exitedChild() {
+ const child = Object.assign(new EventEmitter(), {
+ stdout: new EventEmitter(),
+ stderr: new EventEmitter(),
+ });
+ queueMicrotask(() => child.emit('close', 1, null));
+ return child;
+}
+
+describe('warm seed race consumer cache token', () => {
+ test.each(BLANK_TOKENS)(
+ 'cleanup refuses the blank token %j, reports the refusal and removes nothing',
+ async (token) => {
+ await withTempDir(TEMP_DIR_PREFIX, async (appRoot) => {
+ const parent = installedCacheParent(appRoot);
+ const removeRaceArtifacts = await raceArtifactsUnder(appRoot);
+ expect(
+ removeRaceArtifacts({ runDir: undefined, consumerCacheToken: plantedRunCopy(parent) }),
+ ).toEqual([]);
+ expect(readdirSync(parent).sort()).toEqual(INSTALLED);
+
+ const failures = removeRaceArtifacts({ runDir: undefined, consumerCacheToken: token });
+ expect.soft(readdirSync(parent).sort()).toEqual(INSTALLED);
+ expect.soft(failures).toContainEqual(expect.stringMatching(/consumer ?cache ?token/i));
+ });
+ },
+ );
+
+ test.each(BLANK_TOKENS)(
+ 'the reproduction refuses the blank token %j before it starts the harness or cleans up',
+ async (token) => {
+ await withTempDir(TEMP_DIR_PREFIX, async (appRoot) => {
+ const parent = installedCacheParent(appRoot);
+ const runDir = join(appRoot, 'run');
+ mkdirSync(runDir);
+ const started: string[] = [];
+ const spawn = (_command: string, _args: readonly string[], options: { cwd: string }) => {
+ started.push(options.cwd);
+ return exitedChild();
+ };
+ const exitCode = process.exitCode;
+ vi.stubEnv('PATH', join(appRoot, 'no-executables'));
+ vi.stubEnv('VITE_RACE_RUN_DIR', runDir);
+ vi.doMock('node:child_process', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('node:child_process')>()),
+ spawn,
+ }));
+ redirectAppRoot(appRoot);
+ try {
+ vi.stubEnv('VITE_RACE_CONSUMER_CACHE_TOKEN', plantedRunCopy(parent));
+ vi.resetModules();
+ await expect(import('../stress/_helpers/vite-seed-race/reproduce.mjs')).rejects.toThrow(
+ 'bootstrap failed',
+ );
+ expect(started).toEqual([appRoot]);
+ expect(readdirSync(parent).sort()).toEqual(INSTALLED);
+
+ started.splice(0);
+ vi.stubEnv('VITE_RACE_CONSUMER_CACHE_TOKEN', token);
+ vi.resetModules();
+ expect((await import('node:child_process')).spawn).toBe(spawn);
+ expect((await import('../stress/_helpers/seed-key.ts')).APP_PACKAGE_ROOT).toBe(appRoot);
+ const { removeRaceArtifacts } = await import(
+ '../stress/_helpers/vite-seed-race/race-artifacts.ts'
+ );
+ expect(
+ removeRaceArtifacts({ runDir: undefined, consumerCacheToken: plantedRunCopy(parent) }),
+ ).toEqual([]);
+ expect(readdirSync(parent).sort()).toEqual(INSTALLED);
+
+ await expect
+ .soft(import('../stress/_helpers/vite-seed-race/reproduce.mjs'))
+ .rejects.toThrow('VITE_RACE_CONSUMER_CACHE_TOKEN');
+ expect.soft(started).toEqual([]);
+ expect.soft(readdirSync(parent).sort()).toEqual(INSTALLED);
+ } finally {
+ process.exitCode = exitCode;
+ vi.doUnmock('node:child_process');
+ vi.doUnmock('../stress/_helpers/seed-key.ts');
+ vi.resetModules();
+ vi.unstubAllEnvs();
+ }
+ });
+ },
+ );
+});
diff --git a/packages/app/tests/stress/_helpers/global-warm-cache.ts b/packages/app/tests/stress/_helpers/global-warm-cache.ts
index a6193f9ab..fc66485f9 100644
--- a/packages/app/tests/stress/_helpers/global-warm-cache.ts
+++ b/packages/app/tests/stress/_helpers/global-warm-cache.ts
@@ -1,4 +1,5 @@
import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
import {
existsSync,
mkdirSync,
@@ -6,7 +7,6 @@ import {
readdirSync,
readFileSync,
renameSync,
- rmSync,
statSync,
writeFileSync,
} from 'node:fs';
@@ -20,8 +20,10 @@ import {
createViteStartupRequest,
killGracefully,
openServerLog,
+ resolveViteSeedDir,
tailServerLog,
VITE_E2E_SEED_DIR,
+ VITE_E2E_SEED_POINTER,
waitForBoundViteEndpoint,
waitForHttpReady,
} from './server-process.ts';
@@ -31,6 +33,20 @@ const SEED_KEY_FILENAME = '.seed-key';
const OPTIMIZER_SETTLE_BUDGET_MS = 90_000;
const WARM_ATTEMPTS = 2;
+function publishSeed(buildDir: string): void {
+ const seedParent = dirname(VITE_E2E_SEED_DIR);
+ const publishedDir = join(seedParent, `.vite-e2e-seed-published-${process.pid}-${randomUUID()}`);
+ const pointerTemp = join(seedParent, `.vite-e2e-seed-pointer-${process.pid}-${randomUUID()}`);
+ try {
+ renameSync(buildDir, publishedDir);
+ writeFileSync(pointerTemp, `${publishedDir}\n`, 'utf-8');
+ renameSync(pointerTemp, VITE_E2E_SEED_POINTER);
+ } catch (err) {
+ removeAllDuringTeardown(buildDir, publishedDir, pointerTemp);
+ throw err;
+ }
+}
+
function depsDirSignature(depsDir: string): string {
try {
return readdirSync(depsDir)
@@ -116,8 +132,7 @@ async function buildSeedOnce(key: string): Promise<void> {
}
}
try {
- rmSync(VITE_E2E_SEED_DIR, { recursive: true, force: true });
- renameSync(buildDir, VITE_E2E_SEED_DIR);
+ publishSeed(buildDir);
removeAllDuringTeardown(log.path);
} catch (promoteErr) {
removeAllDuringTeardown(buildDir, log.path);
@@ -127,9 +142,16 @@ async function buildSeedOnce(key: string): Promise<void> {
export default async function globalWarmViteCache(): Promise<void> {
const key = computeSeedKey(APP_PACKAGE_ROOT);
- const keyPath = join(VITE_E2E_SEED_DIR, SEED_KEY_FILENAME);
- const metaPath = join(VITE_E2E_SEED_DIR, 'deps', '_metadata.json');
- if (existsSync(keyPath) && existsSync(metaPath) && readFileSync(keyPath, 'utf-8') === key) {
+ const seedDir = resolveViteSeedDir();
+ const keyPath = seedDir === undefined ? undefined : join(seedDir, SEED_KEY_FILENAME);
+ const metaPath = seedDir === undefined ? undefined : join(seedDir, 'deps', '_metadata.json');
+ if (
+ keyPath !== undefined &&
+ metaPath !== undefined &&
+ existsSync(keyPath) &&
+ existsSync(metaPath) &&
+ readFileSync(keyPath, 'utf-8') === key
+ ) {
return;
}
for (let attempt = 1; attempt <= WARM_ATTEMPTS; attempt += 1) {
diff --git a/packages/app/tests/stress/_helpers/port-ownership/warm-cache.ownership-case.ts b/packages/app/tests/stress/_helpers/port-ownership/warm-cache.ownership-case.ts
index 7444f0404..cac89ab01 100644
--- a/packages/app/tests/stress/_helpers/port-ownership/warm-cache.ownership-case.ts
+++ b/packages/app/tests/stress/_helpers/port-ownership/warm-cache.ownership-case.ts
@@ -1,9 +1,11 @@
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { expect, test } from '@playwright/test';
-import { VITE_E2E_SEED_DIR } from '../server-process.ts';
+import { resolveViteSeedDir } from '../server-process.ts';
test('warm cache owns a serving endpoint before publishing its seed', async () => {
- expect(existsSync(join(VITE_E2E_SEED_DIR, 'deps', '_metadata.json'))).toBe(true);
- expect(existsSync(join(VITE_E2E_SEED_DIR, '.seed-key'))).toBe(true);
+ const seedDir = resolveViteSeedDir();
+ if (seedDir === undefined) throw new Error('warm cache seed pointer is not published');
+ expect(existsSync(join(seedDir, 'deps', '_metadata.json'))).toBe(true);
+ expect(existsSync(join(seedDir, '.seed-key'))).toBe(true);
});
diff --git a/packages/app/tests/stress/_helpers/server-process.ts b/packages/app/tests/stress/_helpers/server-process.ts
index b1831de56..578f3d040 100644
--- a/packages/app/tests/stress/_helpers/server-process.ts
+++ b/packages/app/tests/stress/_helpers/server-process.ts
@@ -32,8 +32,27 @@ export { APP_PACKAGE_ROOT };
export const VITE_E2E_SEED_DIR =
process.env.OK_TEST_VITE_SEED_DIR ?? join(APP_PACKAGE_ROOT, 'node_modules', '.vite-e2e-seed');
-export function viteSeedIsReady(): boolean {
- return existsSync(join(VITE_E2E_SEED_DIR, 'deps', '_metadata.json'));
+export const VITE_E2E_SEED_POINTER = `${VITE_E2E_SEED_DIR}.current`;
+
+export function resolveViteSeedDir(): string | undefined {
+ let pointer: string;
+ try {
+ pointer = readFileSync(VITE_E2E_SEED_POINTER, 'utf-8');
+ } catch (err) {
+ const code = (err as NodeJS.ErrnoException).code;
+ if (code === 'ENOENT') {
+ return existsSync(VITE_E2E_SEED_DIR) ? VITE_E2E_SEED_DIR : undefined;
+ }
+ throw new Error(
+ `the vite seed pointer ${VITE_E2E_SEED_POINTER} could not be read (${code ?? String(err)})`,
+ { cause: err },
+ );
+ }
+ return pointer.trim();
+}
+
+export function viteSeedIsReady(seedDir = resolveViteSeedDir()): boolean {
+ return seedDir !== undefined && existsSync(join(seedDir, 'deps', '_metadata.json'));
}
export function rollbackPreparedViteCacheDir(
@@ -52,11 +71,12 @@ export function rollbackPreparedViteCacheDir(
}
export function prepareViteCacheDir(prefix: string): string {
+ const seedDir = resolveViteSeedDir();
mkdirSync(join(APP_PACKAGE_ROOT, 'node_modules'), { recursive: true });
const dir = mkdtempSync(join(APP_PACKAGE_ROOT, 'node_modules', `.vite-${prefix}-`));
- if (viteSeedIsReady()) {
+ if (seedDir !== undefined && viteSeedIsReady(seedDir)) {
try {
- cpSync(VITE_E2E_SEED_DIR, dir, { recursive: true, force: true });
+ cpSync(seedDir, dir, { recursive: true, force: true });
} catch (err) {
const rollbackFailure = rollbackPreparedViteCacheDir(dir);
if (rollbackFailure !== undefined) console.warn(`[e2e teardown] ${rollbackFailure}`);
diff --git a/packages/app/tests/stress/_helpers/vite-seed-race/bootstrap.mjs b/packages/app/tests/stress/_helpers/vite-seed-race/bootstrap.mjs
new file mode 100644
index 000000000..e1bb6225f
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/vite-seed-race/bootstrap.mjs
@@ -0,0 +1,20 @@
+import { writeFileSync } from 'node:fs';
+
+try {
+ const { default: globalWarmViteCache } = await import(
+ new URL('../global-warm-cache.ts', import.meta.url)
+ );
+ await globalWarmViteCache();
+ writeFileSync(process.env.VITE_RACE_RESULT, JSON.stringify({ status: 'passed' }));
+} catch (error) {
+ writeFileSync(
+ process.env.VITE_RACE_RESULT,
+ JSON.stringify({
+ status: 'failed',
+ name: error?.name,
+ message: String(error?.message ?? error),
+ }),
+ );
+ process.stderr.write(`${String(error?.stack ?? error)}\n`);
+ process.exitCode = 1;
+}
diff --git a/packages/app/tests/stress/_helpers/vite-seed-race/consumer.mjs b/packages/app/tests/stress/_helpers/vite-seed-race/consumer.mjs
new file mode 100644
index 000000000..73736510e
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/vite-seed-race/consumer.mjs
@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+import { dirname, join } from 'node:path';
+
+const consumerReady = process.env.VITE_RACE_CONSUMER_READY;
+const producerIntent = process.env.VITE_RACE_PRODUCER_INTENT;
+const producerPublished = process.env.VITE_RACE_PRODUCER_PUBLISHED;
+const consumerAfterPublish = process.env.VITE_RACE_CONSUMER_AFTER_PUBLISH;
+const consumerCopyDone = process.env.VITE_RACE_CONSUMER_COPY_DONE;
+const seedDir = process.env.OK_TEST_VITE_SEED_DIR;
+const consumerCacheToken = process.env.VITE_RACE_CONSUMER_CACHE_TOKEN;
+const pointerPath = `${seedDir}.current`;
+const expectedSource = existsSync(pointerPath) ? readFileSync(pointerPath, 'utf8').trim() : seedDir;
+const deadline = Date.now() + Number(process.env.VITE_RACE_WAIT_MS ?? '180000');
+const waitForProducer = () => {
+ while (!existsSync(producerPublished)) {
+ if (Date.now() >= deadline) throw new Error('producer publication did not complete');
+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+ }
+};
+
+if (
+ !consumerReady ||
+ !producerIntent ||
+ !producerPublished ||
+ !consumerAfterPublish ||
+ !consumerCopyDone ||
+ !seedDir ||
+ !consumerCacheToken
+)
+ throw new Error('race harness inputs missing');
+mkdirSync(dirname(consumerReady), { recursive: true });
+const fs = (await import('node:fs')).default;
+const originalCpSync = fs.cpSync;
+fs.cpSync = (...args) => {
+ if (args[0] !== expectedSource) return originalCpSync(...args);
+ writeFileSync(consumerReady, 'ready\n');
+ waitForProducer();
+ writeFileSync(consumerAfterPublish, `${existsSync(expectedSource)}\n`);
+ try {
+ return originalCpSync(...args);
+ } finally {
+ writeFileSync(consumerCopyDone, 'copy-done\n');
+ }
+};
+syncBuiltinESMExports();
+
+try {
+ const { prepareViteCacheDir } = await import(new URL('../server-process.ts', import.meta.url));
+ const dir = prepareViteCacheDir(`race-${consumerCacheToken}`);
+ const copiedMetadata = existsSync(join(dir, 'deps', '_metadata.json'));
+ writeFileSync(
+ process.env.VITE_RACE_RESULT,
+ JSON.stringify({ status: copiedMetadata ? 'passed' : 'failed', dir, copiedMetadata }),
+ );
+} catch (error) {
+ writeFileSync(
+ process.env.VITE_RACE_RESULT,
+ JSON.stringify({
+ status: 'failed',
+ name: error?.name,
+ message: String(error?.message ?? error),
+ }),
+ );
+ process.stderr.write(`${String(error?.stack ?? error)}\n`);
+ process.exitCode = 1;
+}
diff --git a/packages/app/tests/stress/_helpers/vite-seed-race/producer.mjs b/packages/app/tests/stress/_helpers/vite-seed-race/producer.mjs
new file mode 100644
index 000000000..46b5f1341
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/vite-seed-race/producer.mjs
@@ -0,0 +1,78 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+import { dirname } from 'node:path';
+
+const seedDir = process.env.OK_TEST_VITE_SEED_DIR;
+const consumerReady = process.env.VITE_RACE_CONSUMER_READY;
+const producerIntent = process.env.VITE_RACE_PRODUCER_INTENT;
+const producerPublished = process.env.VITE_RACE_PRODUCER_PUBLISHED;
+const producerRemoved = process.env.VITE_RACE_PRODUCER_REMOVED;
+const consumerCopyDone = process.env.VITE_RACE_CONSUMER_COPY_DONE;
+const pointerPath = `${seedDir}.current`;
+const deadline = Date.now() + Number(process.env.VITE_RACE_WAIT_MS ?? '180000');
+const waitForConsumer = () => {
+ while (!existsSync(consumerReady)) {
+ if (Date.now() >= deadline)
+ throw new Error('consumer copy did not reach its synchronization gate');
+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+ }
+};
+
+if (
+ !seedDir ||
+ !consumerReady ||
+ !producerIntent ||
+ !producerPublished ||
+ !producerRemoved ||
+ !consumerCopyDone
+)
+ throw new Error('race harness inputs missing');
+mkdirSync(dirname(producerIntent), { recursive: true });
+const fs = (await import('node:fs')).default;
+const originalRmSync = fs.rmSync;
+const originalRenameSync = fs.renameSync;
+const publish = (operation) => {
+ writeFileSync(producerIntent, 'intent\n');
+ waitForConsumer();
+ operation();
+ writeFileSync(producerRemoved, `${existsSync(seedDir)}\n`);
+ writeFileSync(producerPublished, 'published\n');
+ while (!existsSync(consumerCopyDone)) {
+ if (Date.now() >= deadline) throw new Error('consumer copy did not settle');
+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+ }
+};
+fs.rmSync = (target, ...args) => {
+ if (target === seedDir) {
+ publish(() => originalRmSync(target, ...args));
+ return;
+ }
+ return originalRmSync(target, ...args);
+};
+fs.renameSync = (source, target) => {
+ if (target === pointerPath) {
+ publish(() => originalRenameSync(source, target));
+ return;
+ }
+ return originalRenameSync(source, target);
+};
+syncBuiltinESMExports();
+
+try {
+ const { default: globalWarmViteCache } = await import(
+ new URL('../global-warm-cache.ts', import.meta.url)
+ );
+ await globalWarmViteCache();
+ writeFileSync(process.env.VITE_RACE_RESULT, JSON.stringify({ status: 'passed' }));
+} catch (error) {
+ writeFileSync(
+ process.env.VITE_RACE_RESULT,
+ JSON.stringify({
+ status: 'failed',
+ name: error?.name,
+ message: String(error?.message ?? error),
+ }),
+ );
+ process.stderr.write(`${String(error?.stack ?? error)}\n`);
+ process.exitCode = 1;
+}
diff --git a/packages/app/tests/stress/_helpers/vite-seed-race/race-artifacts.ts b/packages/app/tests/stress/_helpers/vite-seed-race/race-artifacts.ts
new file mode 100644
index 000000000..c4ddb1c24
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/vite-seed-race/race-artifacts.ts
@@ -0,0 +1,38 @@
+import { readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { APP_PACKAGE_ROOT } from '../seed-key.ts';
+
+const CONSUMER_CACHE_PARENT = join(APP_PACKAGE_ROOT, 'node_modules');
+
+export function consumerCacheTokenIdentifiesOneRun(consumerCacheToken: string): boolean {
+ return consumerCacheToken.trim() !== '';
+}
+
+export function removeRaceArtifacts(run: {
+ runDir: string | undefined;
+ consumerCacheToken: string;
+}): string[] {
+ const failures: string[] = [];
+ const remove = (path: string) => {
+ try {
+ rmSync(path, { recursive: true, force: true });
+ } catch (error) {
+ failures.push(`${path}: ${String(error)}`);
+ }
+ };
+ if (!consumerCacheTokenIdentifiesOneRun(run.consumerCacheToken)) {
+ failures.push(
+ `the consumer cache token ${JSON.stringify(run.consumerCacheToken)} is blank and cannot identify one run, so nothing under ${CONSUMER_CACHE_PARENT} was removed`,
+ );
+ } else {
+ try {
+ for (const name of readdirSync(CONSUMER_CACHE_PARENT)) {
+ if (name.includes(run.consumerCacheToken)) remove(join(CONSUMER_CACHE_PARENT, name));
+ }
+ } catch (error) {
+ failures.push(`${CONSUMER_CACHE_PARENT}: ${String(error)}`);
+ }
+ }
+ if (run.runDir !== undefined) remove(run.runDir);
+ return failures;
+}
diff --git a/packages/app/tests/stress/_helpers/vite-seed-race/reproduce.mjs b/packages/app/tests/stress/_helpers/vite-seed-race/reproduce.mjs
new file mode 100644
index 000000000..6f4a6b7b7
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/vite-seed-race/reproduce.mjs
@@ -0,0 +1,132 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { APP_PACKAGE_ROOT } from '../seed-key.ts';
+import { consumerCacheTokenIdentifiesOneRun, removeRaceArtifacts } from './race-artifacts.ts';
+
+const givenConsumerCacheToken = process.env.VITE_RACE_CONSUMER_CACHE_TOKEN;
+if (
+ givenConsumerCacheToken !== undefined &&
+ !consumerCacheTokenIdentifiesOneRun(givenConsumerCacheToken)
+)
+ throw new Error(
+ 'VITE_RACE_CONSUMER_CACHE_TOKEN is set but blank, so it cannot identify this run; unset it to generate one',
+ );
+const consumerCacheToken = givenConsumerCacheToken ?? randomUUID();
+const givenRunDir = process.env.VITE_RACE_RUN_DIR;
+const runDir = givenRunDir ?? mkdtempSync(join(tmpdir(), 'ok-vite-warm-race-'));
+const seedDir = join(runDir, 'seed');
+const consumerReady = join(runDir, 'consumer-ready');
+const producerIntent = join(runDir, 'producer-intent');
+const producerPublished = join(runDir, 'producer-published');
+const producerRemoved = join(runDir, 'producer-removed');
+const consumerAfterPublish = join(runDir, 'consumer-after-publish');
+const consumerCopyDone = join(runDir, 'consumer-copy-done');
+const consumerResult = join(runDir, 'consumer-result.json');
+const producerResult = join(runDir, 'producer-result.json');
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const phase = (message) => {
+ process.stderr.write(`[vite-seed-race] ${message}\n`);
+};
+const envBase = {
+ ...process.env,
+ OK_TEST_VITE_SEED_DIR: seedDir,
+ VITE_RACE_CONSUMER_READY: consumerReady,
+ VITE_RACE_PRODUCER_INTENT: producerIntent,
+ VITE_RACE_PRODUCER_PUBLISHED: producerPublished,
+ VITE_RACE_PRODUCER_REMOVED: producerRemoved,
+ VITE_RACE_CONSUMER_AFTER_PUBLISH: consumerAfterPublish,
+ VITE_RACE_CONSUMER_COPY_DONE: consumerCopyDone,
+ VITE_RACE_CONSUMER_CACHE_TOKEN: consumerCacheToken,
+ VITE_RACE_WAIT_MS: '180000',
+};
+const run = (label, script, result) =>
+ new Promise((resolve, reject) => {
+ phase(`${label} started`);
+ const child = spawn('pnpm', ['exec', 'tsx', script], {
+ cwd: APP_PACKAGE_ROOT,
+ env: { ...envBase, VITE_RACE_RESULT: result },
+ stdio: ['ignore', 'pipe', 'pipe'],
+ });
+ let stdout = '';
+ let stderr = '';
+ child.stdout.on('data', (chunk) => {
+ stdout += chunk;
+ });
+ child.stderr.on('data', (chunk) => {
+ stderr += chunk;
+ process.stderr.write(chunk);
+ });
+ child.once('error', reject);
+ child.once('close', (code, signal) => {
+ phase(`${label} exited with code ${String(code)} and signal ${String(signal)}`);
+ resolve({ code, signal, stdout, stderr });
+ });
+ });
+
+try {
+ phase(`run directory ${runDir}, consumer cache token ${consumerCacheToken}`);
+ const bootstrap = await run(
+ 'bootstrap warm build',
+ join(scriptDir, 'bootstrap.mjs'),
+ join(runDir, 'bootstrap-result.json'),
+ );
+ if (bootstrap.code !== 0) throw new Error(`bootstrap failed: ${bootstrap.stderr}`);
+ const publishedSeed = existsSync(`${seedDir}.current`)
+ ? readFileSync(`${seedDir}.current`, 'utf8').trim()
+ : seedDir;
+ writeFileSync(join(publishedSeed, '.seed-key'), 'stale-race-key\n');
+ const consumerPromise = run('consumer copy', join(scriptDir, 'consumer.mjs'), consumerResult);
+ const producerPromise = run(
+ 'producer warm build',
+ join(scriptDir, 'producer.mjs'),
+ producerResult,
+ );
+ const [consumer, producer] = await Promise.all([consumerPromise, producerPromise]);
+ const publishedSeedAfterBootstrap = existsSync(`${seedDir}.current`)
+ ? readFileSync(`${seedDir}.current`, 'utf8').trim()
+ : seedDir;
+ const result = {
+ runDir,
+ seedReadyAfterBootstrap: existsSync(
+ join(publishedSeedAfterBootstrap, 'deps', '_metadata.json'),
+ ),
+ consumer,
+ producer,
+ consumerResult: existsSync(consumerResult)
+ ? JSON.parse(readFileSync(consumerResult, 'utf8'))
+ : null,
+ producerResult: existsSync(producerResult)
+ ? JSON.parse(readFileSync(producerResult, 'utf8'))
+ : null,
+ producerIntentReached: existsSync(producerIntent),
+ producerPublished: existsSync(producerPublished),
+ producerRemoved: existsSync(producerRemoved) ? readFileSync(producerRemoved, 'utf8') : null,
+ consumerAfterPublish: existsSync(consumerAfterPublish)
+ ? readFileSync(consumerAfterPublish, 'utf8')
+ : null,
+ consumerCopyDone: existsSync(consumerCopyDone),
+ consumerReadyReached: existsSync(consumerReady),
+ };
+ process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+ if (
+ result.consumerResult?.status !== 'passed' ||
+ result.producerResult?.status !== 'passed' ||
+ !result.producerPublished
+ )
+ process.exitCode = 1;
+} finally {
+ const failures = removeRaceArtifacts({
+ runDir: givenRunDir === undefined ? runDir : undefined,
+ consumerCacheToken,
+ });
+ if (failures.length > 0) {
+ phase(`cleanup could not remove:\n${failures.join('\n')}`);
+ process.exitCode = 1;
+ } else {
+ phase('cleanup finished');
+ }
+}