Build: Replace rollup-plugin-dts with rolldown-plugin-dts + tsgo for ~16x faster d.ts generation

nx.json

@@ -205,5 +205,5 @@
     ]
   },
   "analytics": false,
-  "codexCacheBust": "2026-03-23T12:57:22Z"
+  "codexCacheBust": "2026-03-26T08:49:19Z"
 }

package.json

@@ -64,13 +64,17 @@
     "@nx/workspace": "^22.6.1",
     "@playwright/test": "^1.58.2",
     "@types/kill-port": "^2.0.3",
+    "@typescript/native-preview": "^7.0.0-dev.20260325.1",
     "http-server": "^14.1.1",
     "husky": "^9.1.7",
     "jiti": "^2.6.1",
     "kill-port": "^2.0.1",
     "lint-staged": "^16.4.0",
     "nx": "^22.6.1",
+    "oxc-transform": "0.121.0",
     "oxfmt": "^0.41.0",
+    "rolldown": "^1.0.0-rc.12",
+    "rolldown-plugin-dts": "^0.23.0",
     "std-env": "^4.0.0",
     "vite": "^7.0.4",
     "vitest": "^4.1.0"

scripts/build/utils/generate-types.ts

@@ -1,109 +1,67 @@
-import { spawn } from 'child_process';
-import limit from 'p-limit';
+import { sep } from 'node:path';
+
 import { join, relative } from 'pathe';
 import picocolors from 'picocolors';
+import { rolldown } from 'rolldown';
+import { dts } from 'rolldown-plugin-dts';
 
-import { ROOT_DIRECTORY } from '../../utils/constants';
 import type { BuildEntries } from './entry-utils';
+import { getExternal } from './entry-utils';
 
 const DIR_CODE = join(import.meta.dirname, '..', '..', '..', 'code');
 
-const MAX_DTS_ATTEMPTS = 2;
-const RETRY_DELAY_MS = 500;
-
 export async function generateTypesFiles(cwd: string, data: BuildEntries) {
-  const DIR_CWD = cwd;
-  const DIR_REL = relative(DIR_CODE, DIR_CWD);
+  const DIR_REL = relative(DIR_CODE, cwd);
 
   const dtsEntries = Object.values(data.entries)
     .flat()
     .filter((entry) => entry.dts !== false)
     .map((e) => e.entryPoint);
 
-  // Spawn each entry in it's own separate process, because they are slow & synchronous
-  // ...this way we do not bog down the main process/esbuild and can run them in parallel
-  // we limit the number of concurrent processes to 3, because we don't want to overload the host machine
-  // by trial and error, 3 seems to be the sweet spot between perf and consistency
-  const limited = limit(5);
-  let processes: ReturnType<typeof spawn>[] = [];
-
-  await Promise.all(
-    dtsEntries.map(async (entryPoint) => {
-      return limited(async () => {
-        for (let attempt = 1; attempt <= MAX_DTS_ATTEMPTS; attempt++) {
-          let timer: ReturnType<typeof setTimeout> | undefined;
-          const dtsProcess = spawn(
-            `"${join(ROOT_DIRECTORY, 'node_modules', '.bin', 'jiti')}"`,
-            [`"${join(import.meta.dirname, 'dts-process.ts')}"`, `"${entryPoint}"`],
-            {
-              shell: true,
-              cwd: DIR_CWD,
-              stdio: ['ignore', 'inherit', 'pipe'],
-            }
-          );
-          processes.push(dtsProcess);
+  if (dtsEntries.length === 0) {
+    return;
+  }
 
-          // Filter stderr to exclude messages containing "are imported from external module", which is an ignorable warning from rollup
-          dtsProcess.stderr?.on('data', (data) => {
-            const message = data.toString();
-            if (!message.includes('are imported from external module')) {
-              process.stderr.write(data);
-            }
-          });
+  const { typesExternal: external } = await getExternal(cwd);
 
-          await Promise.race([
-            new Promise((resolve) => {
-              dtsProcess.on('exit', () => {
-                resolve(void 0);
-              });
-              dtsProcess.on('error', () => {
-                resolve(void 0);
-              });
-              dtsProcess.on('close', () => {
-                resolve(void 0);
-              });
-            }),
-            new Promise((resolve) => {
-              timer = setTimeout(() => {
-                console.log('⌛ Timed out generating d.ts files for', entryPoint);
+  const externalFn = (id: string) =>
+    external.some(
+      (dep: string) =>
+        id === dep ||
+        id.startsWith(`${dep}/`) ||
+        id.includes(`${sep}node_modules${sep}${dep}${sep}`)
+    );
 
-                dtsProcess.kill(408); // timed out
-                resolve(void 0);
-              }, 120000);
-            }),
-          ]);
+  // Build entry map: { 'client-logger/index': '/absolute/path/src/client-logger/index.ts', ... }
+  const entryMap: Record<string, string> = {};
+  for (const entry of dtsEntries) {
+    // ./src/client-logger/index.ts -> client-logger/index
+    const name = entry.replace(/^\.\/src\//, '').replace(/\.tsx?$/, '');
+    entryMap[name] = join(cwd, entry);
+  }
 
-          if (timer) {
-            clearTimeout(timer);
-          }
+  // Use rolldown + rolldown-plugin-dts with tsgo for fast d.ts generation.
+  // tsgo (Go-based TypeScript compiler) runs once for all entries (~7s),
+  // then rolldown bundles the declarations natively in Rust.
+  const out = await rolldown({
+    input: entryMap,
+    external: externalFn,
+    plugins: [
+      dts({
+        cwd,
+        tsconfig: join(cwd, 'tsconfig.json'),
+        tsgo: true,
+        emitDtsOnly: true,
+      }),
+    ],
+    logLevel: 'warn',
+  });
 
-          if (dtsProcess.exitCode !== 0) {
-            if (attempt < MAX_DTS_ATTEMPTS) {
-              // Race: parallel DTS can read a .d.ts another process is still writing → invalid. Retry + delay usually fixes (flake in core:compile:production since #33759).
-              console.warn(
-                `⚠️ DTS failed for ${picocolors.cyan(relative(cwd, entryPoint))}, retrying (${attempt}/${MAX_DTS_ATTEMPTS})...`
-              );
-              processes = processes.filter((p) => p !== dtsProcess);
-              await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-              continue;
-            }
-            console.error(
-              '\n❌ Generating types for',
-              picocolors.cyan(relative(cwd, entryPoint)),
-              ' failed'
-            );
-            // If any fail after all retries, kill all the other processes and exit (bail)
-            processes.forEach((p) => p.kill());
-            processes = [];
-            process.exit(dtsProcess.exitCode || 1);
-          }
+  await out.write({ dir: join(cwd, 'dist'), format: 'es' });
 
-          if (!process.env.CI) {
-            console.log('✅ Generated types for', picocolors.cyan(join(DIR_REL, entryPoint)));
-          }
-          break;
-        }
-      });
-    })
-  );
+  if (!process.env.CI) {
+    for (const entry of dtsEntries) {
+      console.log('Generated types for', picocolors.cyan(join(DIR_REL, entry)));
+    }
+  }
 }