Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.mjsnew file mode 100644index 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.mjsnew file mode 100644index 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.mjsnew file mode 100644index 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.tsnew file mode 100644index 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.mjsnew file mode 100644index 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');+ }+}