fix(new-compiler): force synced metadata writes

Author: visoar

packages/new-compiler/src/metadata/fixtures/save-metadata-worker.ts

@@ -0,0 +1,38 @@
+import { saveMetadata } from "../manager";
+import { generateTranslationHash } from "../../utils/hash";
+
+const dbPath = process.argv[2];
+const workerId = Number(process.argv[3]);
+const iterations = Number(process.argv[4]);
+const noSync = process.argv[5] === "true";
+
+function createEntry(i: number) {
+  const sourceText = `worker-${workerId}-entry-${i}`;
+  const context = {
+    filePath: `worker-${workerId}.tsx`,
+    componentName: "WorkerComponent",
+  };
+
+  return {
+    type: "content" as const,
+    sourceText,
+    context,
+    location: {
+      filePath: `worker-${workerId}.tsx`,
+      line: i + 1,
+      column: 1,
+    },
+    hash: generateTranslationHash(sourceText, context),
+  };
+}
+
+async function main() {
+  for (let i = 0; i < iterations; i += 1) {
+    await saveMetadata(dbPath, [createEntry(i)], noSync);
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

packages/new-compiler/src/metadata/manager.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { spawn } from "child_process";
 import {
   loadMetadata,
   saveMetadata,
@@ -29,6 +30,62 @@ function createUniqueDbPath(): string {
   );
 }
 
+async function runSaveMetadataWorker(
+  dbPath: string,
+  workerId: number,
+  iterations: number,
+  noSync: boolean,
+): Promise<void> {
+  const tsxBinary = path.resolve(
+    import.meta.dirname,
+    "../../node_modules/.bin/tsx",
+  );
+  const workerScript = path.resolve(
+    import.meta.dirname,
+    "./fixtures/save-metadata-worker.ts",
+  );
+
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(
+      tsxBinary,
+      [
+        workerScript,
+        dbPath,
+        String(workerId),
+        String(iterations),
+        String(noSync),
+      ],
+      {
+        cwd: path.resolve(import.meta.dirname, "../.."),
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+      },
+    );
+
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(
+        new Error(
+          `worker ${workerId} failed (code=${code}, signal=${signal})\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+        ),
+      );
+    });
+  });
+}
+
 describe("metadata", () => {
   let testDbPath: string;
 
@@ -126,6 +183,26 @@ describe("metadata", () => {
     });
   });
 
+  describe("concurrent access (multi process)", () => {
+    it(
+      "should preserve all entries when multiple processes request noSync writes",
+      async () => {
+        const workers = 6;
+        const iterations = 40;
+
+        await Promise.all(
+          Array.from({ length: workers }, (_, workerId) =>
+            runSaveMetadataWorker(testDbPath, workerId, iterations, true),
+          ),
+        );
+
+        const final = await loadMetadata(testDbPath);
+        expect(Object.keys(final).length).toBe(workers * iterations);
+      },
+      30_000,
+    );
+  });
+
   describe("cleanupExistingMetadata", () => {
     it("should remove database and allow reopening with fresh state", async () => {
       const entry = createTestEntry("before");

packages/new-compiler/src/metadata/manager.ts

@@ -7,6 +7,7 @@ import { logger } from "../utils/logger";
 
 const METADATA_DIR_DEV = "metadata-dev";
 const METADATA_DIR_BUILD = "metadata-build";
+const METADATA_DB_NO_SYNC = false;
 
 /**
  * Opens an LMDB connection for a single operation.
@@ -21,10 +22,14 @@ async function openDatabaseConnection(dbPath: string, noSync: boolean): Promise<
   try {
     fs.mkdirSync(dbPath, { recursive: true });
     const { open } = await import("lmdb");
+    const effectiveNoSync = noSync ? METADATA_DB_NO_SYNC : false;
     return open({
       path: dbPath,
       compression: true,
-      noSync,
+      // Metadata is written from multiple bundler worker processes to the same LMDB path.
+      // Enabling `noSync` here can abort worker processes or silently drop entries under
+      // concurrent production builds, so metadata always uses fully synchronized commits.
+      noSync: effectiveNoSync,
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);