@d1g1tal/tsbuild 1.8.6 → 1.8.8

package/dist/{2LQAKZEG.js → RJIPAUMH.js}

@@ -23,19 +23,21 @@ import {
   dtsCacheVersion,
   format,
   newLine,
+  outputManifestFile,
   processEnvExpansionPattern,
   sourceScriptExtensionExpression,
   toEsTarget,
   toJsxRenderingMode,
   typeMatcher
-} from "./JKGYA2AW.js";
+} from "./QL4XMDMJ.js";
 
 // src/files.ts
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import { serialize, deserialize } from "node:v8";
 import { brotliDecompress, brotliCompress } from "node:zlib";
 import { access, constants, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-var Files = class _Files {
+var windowsDrivePathRegex = /^[A-Za-z]:[\\/]/;
+var Files = class {
   constructor() {
   }
   /**
@@ -55,13 +57,31 @@ var Files = class _Files {
     }
   }
   /**
-   * Clear a directory by removing all files and subdirectories.
+   * Clear a directory by removing all of its entries in parallel.
+   * Uses readdir + parallel rm so libuv's threadpool can unlink subtrees concurrently,
+   * which is significantly faster than a single recursive `rm` for large output trees.
+   * The directory itself is preserved (no mkdir needed afterward).
    * @param directory The path to the directory to clear.
    */
   static async empty(directory) {
-    if (await _Files.exists(directory)) {
-      await Promise.all((await readdir(directory)).map((file) => rm(Paths.join(directory, file), defaultCleanOptions)));
+    let entries;
+    try {
+      entries = await readdir(directory);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        await mkdir(directory, defaultDirOptions);
+        return;
+      }
+      throw error;
+    }
+    if (entries.length === 0) {
+      return;
     }
+    const removals = new Array(entries.length);
+    for (let i = 0, length = entries.length; i < length; i++) {
+      removals[i] = rm(join(directory, entries[i]), defaultCleanOptions);
+    }
+    await Promise.all(removals);
   }
   /**
    * Write data to a file.
@@ -95,9 +115,16 @@ var Files = class _Files {
    * Normalize a file path to an absolute path.
    * @param path The file path to normalize.
    * @returns The normalized absolute path.
+   * @throws {TypeError} if path is relative and not a valid URL
    */
   static normalizePath(path) {
-    return path.startsWith("/") || path.startsWith("file://") ? path : new URL(path, import.meta.url).pathname;
+    if (path.startsWith("/") || path.startsWith("file://") || windowsDrivePathRegex.test(path)) {
+      return path;
+    }
+    if (!path.includes("://")) {
+      throw new TypeError(`Files.normalizePath requires an absolute path, got: ${path}`);
+    }
+    return new URL(path, import.meta.url).pathname;
   }
   /**
    * Decompress a Brotli-compressed buffer.
@@ -390,6 +417,9 @@ var Logger = class _Logger {
   }
 };
 
+// src/type-script-project.ts
+import { rm as rm2 } from "node:fs/promises";
+
 // src/dts/declaration-bundler.ts
 import MagicString2 from "magic-string";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
@@ -472,6 +502,7 @@ import {
   isEmptyStatement,
   isEnumDeclaration,
   isExportDeclaration,
+  isExportSpecifier,
   isFunctionDeclaration,
   isIdentifier,
   isImportDeclaration,
@@ -491,6 +522,7 @@ import {
   getCombinedModifierFlags
 } from "typescript";
 import MagicString from "magic-string";
+var commaCharacter = 44;
 var DeclarationProcessor = class _DeclarationProcessor {
   constructor() {
   }
@@ -695,21 +727,31 @@ var DeclarationProcessor = class _DeclarationProcessor {
         }
         const { flags } = node.declarationList;
         const prefix = `declare ${flags & NodeFlags.Let ? "let" : flags & NodeFlags.Const ? "const" : "var"} `;
-        let commaPos = 0;
-        for (const declarationNode of node.declarationList.getChildren().find((n) => n.kind === SyntaxKind2.SyntaxList)?.getChildren() ?? []) {
-          if (declarationNode.kind === SyntaxKind2.CommaToken) {
-            code.remove(commaPos = declarationNode.getStart(), declarationNode.getEnd());
-          } else if (commaPos) {
-            code.appendLeft(commaPos, `;${newLine}`);
-            const start = declarationNode.getFullStart();
-            const slice = code.slice(start, declarationNode.getStart());
-            const whitespace = slice.length - slice.trimStart().length;
-            if (whitespace) {
-              code.overwrite(start, start + whitespace, prefix);
-            } else {
-              code.appendLeft(start, prefix);
+        const sourceText = sourceFile.text;
+        for (let i = 1; i < declarations.length; i++) {
+          const prev = declarations[i - 1];
+          const curr = declarations[i];
+          let commaPos = -1;
+          const limit = curr.getStart();
+          for (let p = prev.end; p < limit; p++) {
+            if (sourceText.charCodeAt(p) === commaCharacter) {
+              commaPos = p;
+              break;
             }
           }
+          if (commaPos === -1) {
+            continue;
+          }
+          code.remove(commaPos, commaPos + 1);
+          code.appendLeft(commaPos, `;${newLine}`);
+          const start = curr.getFullStart();
+          const slice = sourceText.substring(start, curr.getStart());
+          const whitespace = slice.length - slice.trimStart().length;
+          if (whitespace) {
+            code.overwrite(start, start + whitespace, prefix);
+          } else {
+            code.appendLeft(start, prefix);
+          }
         }
       }
     }
@@ -776,16 +818,8 @@ var DeclarationProcessor = class _DeclarationProcessor {
           magic.overwrite(node.moduleSpecifier.getStart() + 1, node.moduleSpecifier.getEnd() - 1, replacement);
         }
       }
-      if (isModuleDeclaration(node) && node.body && isModuleBlock(node.body)) {
-        for (const bodyStatement of node.body.statements) {
-          if (isExportDeclaration(bodyStatement) && bodyStatement.exportClause && !isNamespaceExport(bodyStatement.exportClause)) {
-            for (const { name, propertyName } of bodyStatement.exportClause.elements) {
-              if (propertyName && isIdentifier(propertyName) && isIdentifier(name) && propertyName.getText() === name.getText()) {
-                magic.remove(propertyName.getStart(), name.getStart());
-              }
-            }
-          }
-        }
+      if (isExportSpecifier(node) && node.propertyName && isIdentifier(node.propertyName) && isIdentifier(node.name) && node.propertyName.text === node.name.text) {
+        magic.remove(node.propertyName.getStart(), node.name.getStart());
       }
       forEachChild(node, visitNode);
     }
@@ -808,7 +842,9 @@ import {
   isClassDeclaration as isClassDeclaration2,
   isVariableStatement as isVariableStatement2,
   isModuleDeclaration as isModuleDeclaration2,
+  isModuleBlock as isModuleBlock2,
   isNamedExports as isNamedExports2,
+  isNamedImports,
   isIdentifier as isIdentifier2,
   isNamespaceImport,
   isQualifiedName,
@@ -818,35 +854,31 @@ import {
 } from "typescript";
 var nodeModules = "/node_modules/";
 var emptySet = /* @__PURE__ */ new Set();
-var importPattern = /^import\s*(?:type\s*)?\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]\s*;?\s*$/;
-var typePrefixPattern = /^type:/;
 function mergeImports(imports) {
-  const moduleImports = /* @__PURE__ */ new Map();
-  const nonMergeableImports = /* @__PURE__ */ new Set();
-  for (const importStatement of imports) {
-    const match = importPattern.exec(importStatement);
-    if (match) {
-      const [, namesString, moduleSpecifier] = match;
-      const isType = importStatement.includes("import type");
-      const key = `${isType ? "type:" : ""}${moduleSpecifier}`;
-      let entry = moduleImports.get(key);
-      if (entry === void 0) {
-        entry = { names: /* @__PURE__ */ new Set(), isType };
-        moduleImports.set(key, entry);
-      }
-      for (const name of namesString.split(",")) {
-        entry.names.add(name.trim());
-      }
-    } else {
-      nonMergeableImports.add(importStatement);
+  const merged = /* @__PURE__ */ new Map();
+  const raw = /* @__PURE__ */ new Set();
+  for (const imp of imports) {
+    if (imp.kind === "raw") {
+      raw.add(imp.text);
+      continue;
+    }
+    const key = `${imp.isType ? "type:" : ""}${imp.specifier}`;
+    let entry = merged.get(key);
+    if (entry === void 0) {
+      entry = { specifier: imp.specifier, isType: imp.isType, names: /* @__PURE__ */ new Set() };
+      merged.set(key, entry);
+    }
+    for (const name of imp.names) {
+      entry.names.add(name);
     }
   }
   const result = [];
-  for (const [key, { names, isType }] of moduleImports) {
-    result.push(`${isType ? "import type" : "import"} { ${[...names].sort().join(", ")} } from "${key.replace(typePrefixPattern, "")}";`);
+  for (const { specifier, isType, names } of merged.values()) {
+    const sorted = Array.from(names).sort();
+    result.push(`${isType ? "import type" : "import"} { ${sorted.join(", ")} } from "${specifier}";`);
   }
-  for (const imp of nonMergeableImports) {
-    result.push(imp);
+  for (const text of raw) {
+    result.push(text);
   }
   return result;
 }
@@ -859,6 +891,8 @@ var DeclarationBundler = class _DeclarationBundler {
   options;
   /** WeakMap cache for identifier collection to avoid re-parsing same source files */
   identifierCache = /* @__PURE__ */ new WeakMap();
+  /** SourceFile cache keyed by path — survives across multiple bundle() calls (entry points) */
+  sourceFileCache = /* @__PURE__ */ new Map();
   /** Module resolution cache for this bundler instance */
   moduleResolutionCache = /* @__PURE__ */ new Map();
   /** Pre-computed set of directory prefixes from declaration file paths for O(1) directoryExists lookups */
@@ -926,6 +960,7 @@ var DeclarationBundler = class _DeclarationBundler {
   clearExternalFiles() {
     this.externalDeclarationFiles.clear();
     this.moduleResolutionCache.clear();
+    this.sourceFileCache.clear();
   }
   /**
    * Convert a source file path to its corresponding declaration file path
@@ -954,21 +989,6 @@ var DeclarationBundler = class _DeclarationBundler {
     }
     return bestMatch ?? sourcePath;
   }
-  /**
-   * Extract import statements from declaration file content using AST
-   * Handles: import { X } from 'module', import * as X from 'module', export { X } from 'module'
-   * @param sourceFile - The parsed source file AST
-   * @returns Array of module specifiers that are imported
-   */
-  extractImports({ statements }) {
-    const imports = [];
-    for (const statement of statements) {
-      if ((isImportDeclaration2(statement) || isExportDeclaration2(statement)) && statement.moduleSpecifier) {
-        imports.push(statement.moduleSpecifier.text);
-      }
-    }
-    return imports;
-  }
   /**
    * Builds an O(1) matcher from a mixed Pattern array by splitting into a Set<string> for
    * exact/sub-path checks and a RegExp[] for regex tests. Called once per bundler instance.
@@ -1050,22 +1070,29 @@ var DeclarationBundler = class _DeclarationBundler {
         return;
       }
       const { code, typeReferences, fileReferences } = cached;
-      const sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
+      let sourceFile = this.sourceFileCache.get(path);
+      if (sourceFile === void 0) {
+        sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
+        this.sourceFileCache.set(path, sourceFile);
+      }
       const identifiers = this.collectIdentifiers(sourceFile.statements, sourceFile);
       const module = { path, code, imports: /* @__PURE__ */ new Set(), typeReferences: new Set(typeReferences), fileReferences: new Set(fileReferences), sourceFile, identifiers };
       const bundledSpecs = /* @__PURE__ */ new Set();
-      for (const specifier of this.extractImports(sourceFile)) {
-        if (this.matchExternal(specifier)) {
-          continue;
-        }
-        const resolvedPath = this.resolveModule(specifier, path);
-        if (resolvedPath?.includes(nodeModules) && !this.matchNoExternal(specifier)) {
-          continue;
-        }
-        if (resolvedPath && (this.declarationFiles.has(resolvedPath) || this.externalDeclarationFiles.has(resolvedPath))) {
-          module.imports.add(resolvedPath);
-          bundledSpecs.add(specifier);
-          visit(resolvedPath);
+      for (const statement of sourceFile.statements) {
+        if ((isImportDeclaration2(statement) || isExportDeclaration2(statement)) && statement.moduleSpecifier) {
+          const specifier = statement.moduleSpecifier.text;
+          if (this.matchExternal(specifier)) {
+            continue;
+          }
+          const resolvedPath = this.resolveModule(specifier, path);
+          if (resolvedPath?.includes(nodeModules) && !this.matchNoExternal(specifier)) {
+            continue;
+          }
+          if (resolvedPath && (this.declarationFiles.has(resolvedPath) || this.externalDeclarationFiles.has(resolvedPath))) {
+            module.imports.add(resolvedPath);
+            bundledSpecs.add(specifier);
+            visit(resolvedPath);
+          }
         }
       }
       modules.set(path, module);
@@ -1160,7 +1187,12 @@ var DeclarationBundler = class _DeclarationBundler {
         if (statement.name && isIdentifier2(statement.name)) {
           values.add(statement.name.text);
         }
-        collectNestedIdentifiers(statement.getChildren());
+        const body = statement.body;
+        if (body && isModuleBlock2(body)) {
+          collectNestedIdentifiers(body.statements);
+        } else if (body && isModuleDeclaration2(body)) {
+          collectNestedIdentifiers([body]);
+        }
       }
     }
     result = { types, values };
@@ -1188,7 +1220,13 @@ var DeclarationBundler = class _DeclarationBundler {
     const magic = new MagicString2(code);
     const moduleRenames = /* @__PURE__ */ new Map();
     const exportsMapper = (name) => moduleRenames.get(name) ?? name;
-    for (const name of [...typeIdentifiers, ...valueIdentifiers]) {
+    for (const name of typeIdentifiers) {
+      const renamed = renameMap.get(`${name}:${modulePath}`);
+      if (renamed) {
+        moduleRenames.set(name, renamed);
+      }
+    }
+    for (const name of valueIdentifiers) {
       const renamed = renameMap.get(`${name}:${modulePath}`);
       if (renamed) {
         moduleRenames.set(name, renamed);
@@ -1199,7 +1237,21 @@ var DeclarationBundler = class _DeclarationBundler {
       if (isImportDeclaration2(statement)) {
         const moduleSpecifier = statement.moduleSpecifier.text;
         if (this.matchExternal(moduleSpecifier) || !bundledImportPaths.has(moduleSpecifier)) {
-          externalImports.push(code.substring(statement.pos, statement.end).trim());
+          const importClause = statement.importClause;
+          const isTypeOnly = importClause?.isTypeOnly === true;
+          const namedBindings = importClause?.namedBindings;
+          if (importClause && !importClause.name && namedBindings && isNamedImports(namedBindings)) {
+            const names = [];
+            for (const element of namedBindings.elements) {
+              const local = element.name.text;
+              const original = element.propertyName?.text;
+              const prefix = element.isTypeOnly ? "type " : "";
+              names.push(original ? `${prefix}${original} as ${local}` : `${prefix}${local}`);
+            }
+            externalImports.push({ kind: "named", specifier: moduleSpecifier, isType: isTypeOnly, names });
+          } else {
+            externalImports.push({ kind: "raw", text: code.substring(statement.pos, statement.end).trim() });
+          }
         } else if (statement.importClause?.namedBindings && isNamespaceImport(statement.importClause.namedBindings)) {
           bundledNamespaceAliases.add(statement.importClause.namedBindings.name.text);
         }
@@ -1228,9 +1280,13 @@ var DeclarationBundler = class _DeclarationBundler {
         magic.remove(statement.pos, statement.end);
       }
     }
-    if (moduleRenames.size > 0) {
+    const hasRenames = moduleRenames.size > 0;
+    const hasBundledAliases = bundledNamespaceAliases.size > 0;
+    if (hasRenames || hasBundledAliases) {
       const visit = (node) => {
-        if (isIdentifier2(node)) {
+        if (hasBundledAliases && isQualifiedName(node) && isIdentifier2(node.left) && bundledNamespaceAliases.has(node.left.text)) {
+          magic.remove(node.left.getStart(), node.right.getStart());
+        } else if (hasRenames && isIdentifier2(node)) {
           const renamed = moduleRenames.get(node.text);
           if (renamed) {
             magic.overwrite(node.getStart(), node.end, renamed);
@@ -1244,19 +1300,9 @@ var DeclarationBundler = class _DeclarationBundler {
         }
       }
     }
-    if (bundledNamespaceAliases.size > 0) {
-      const visitQualified = (node) => {
-        if (isQualifiedName(node) && isIdentifier2(node.left) && bundledNamespaceAliases.has(node.left.text)) {
-          magic.remove(node.left.getStart(), node.right.getStart());
-        }
-        forEachChild2(node, visitQualified);
-      };
-      forEachChild2(sourceFile, visitQualified);
-    }
     const finalValueExportsSet = new Set(valueExports.map(exportsMapper));
-    const finalValueExports = [...finalValueExportsSet];
-    const finalTypeExports = [...new Set(typeExports.map(exportsMapper).filter((t) => !finalValueExportsSet.has(t)))];
-    return { code: magic.toString(), externalImports, typeExports: finalTypeExports, valueExports: finalValueExports };
+    const finalTypeExports = [...new Set(typeExports.map(exportsMapper).filter((type2) => !finalValueExportsSet.has(type2)))];
+    return { code: magic.toString(), externalImports, typeExports: finalTypeExports, valueExports: [...finalValueExportsSet] };
   }
   /**
    * Combine modules into a single output string
@@ -1265,27 +1311,30 @@ var DeclarationBundler = class _DeclarationBundler {
    * @returns Object containing combined code, all exported identifiers, and all declarations from bundled modules
    */
   combineModules(sortedModules, bundledSpecifiers) {
-    const allTypeReferences = [];
-    const allFileReferences = [];
+    const typeReferencesSet = /* @__PURE__ */ new Set();
+    const fileReferencesSet = /* @__PURE__ */ new Set();
     const allExternalImports = [];
-    const allTypeExports = [];
-    const allValueExports = [];
+    const valueExportsSet = /* @__PURE__ */ new Set();
+    const typeExportsSeen = /* @__PURE__ */ new Set();
+    const orderedTypeExports = [];
     const codeBlocks = [];
     const allDeclarations = /* @__PURE__ */ new Set();
     const declarationSources = /* @__PURE__ */ new Map();
     const renameMap = /* @__PURE__ */ new Map();
-    for (const { path, identifiers } of sortedModules) {
-      for (const name of identifiers.types) {
-        if (!declarationSources.has(name)) {
-          declarationSources.set(name, /* @__PURE__ */ new Set());
+    for (const { path, identifiers: { types, values } } of sortedModules) {
+      for (const name of types) {
+        let set = declarationSources.get(name);
+        if (set === void 0) {
+          declarationSources.set(name, set = /* @__PURE__ */ new Set());
         }
-        declarationSources.get(name).add(path);
+        set.add(path);
       }
-      for (const name of identifiers.values) {
-        if (!declarationSources.has(name)) {
-          declarationSources.set(name, /* @__PURE__ */ new Set());
+      for (const name of values) {
+        let set = declarationSources.get(name);
+        if (set === void 0) {
+          declarationSources.set(name, set = /* @__PURE__ */ new Set());
         }
-        declarationSources.get(name).add(path);
+        set.add(path);
       }
     }
     for (const [name, sourcesSet] of declarationSources) {
@@ -1303,19 +1352,32 @@ var DeclarationBundler = class _DeclarationBundler {
         }
       }
     }
-    for (const { path, typeReferences, fileReferences, sourceFile, code, identifiers } of sortedModules) {
-      allTypeReferences.push(...typeReferences);
-      allFileReferences.push(...fileReferences);
+    for (const { path, typeReferences, fileReferences, sourceFile, code, identifiers: { types, values } } of sortedModules) {
+      for (const r of typeReferences) {
+        typeReferencesSet.add(r);
+      }
+      for (const r of fileReferences) {
+        fileReferencesSet.add(r);
+      }
       const bundledForThisModule = bundledSpecifiers.get(path) ?? emptySet;
-      const { code: strippedCode, externalImports, typeExports, valueExports } = this.stripImportsExports(code, sourceFile, identifiers, bundledForThisModule, renameMap, path);
-      allExternalImports.push(...externalImports);
+      const { code: strippedCode, externalImports, typeExports, valueExports } = this.stripImportsExports(code, sourceFile, { types, values }, bundledForThisModule, renameMap, path);
+      for (const imp of externalImports) {
+        allExternalImports.push(imp);
+      }
       if (!path.includes(nodeModules)) {
-        allValueExports.push(...valueExports);
-        allTypeExports.push(...typeExports);
-        for (const name of identifiers.types) {
+        for (const exp of valueExports) {
+          valueExportsSet.add(exp);
+        }
+        for (const exp of typeExports) {
+          if (!typeExportsSeen.has(exp)) {
+            typeExportsSeen.add(exp);
+            orderedTypeExports.push(exp);
+          }
+        }
+        for (const name of types) {
           allDeclarations.add(name);
         }
-        for (const name of identifiers.values) {
+        for (const name of values) {
           allDeclarations.add(name);
         }
       }
@@ -1323,27 +1385,37 @@ var DeclarationBundler = class _DeclarationBundler {
         codeBlocks.push(strippedCode.trim());
       }
     }
-    const typeReferencesSet = new Set(allTypeReferences);
-    const uniqueFileReferences = [...new Set(allFileReferences)];
     const mergedExternalImports = mergeImports(allExternalImports);
     for (const imp of mergedExternalImports) {
       if (imp.includes('"node:') || imp.includes("'node:")) {
         typeReferencesSet.add("node");
       }
     }
-    const uniqueTypeReferences = [...typeReferencesSet];
-    const finalValueExportsSet = new Set(allValueExports);
-    const finalValueExports = [...finalValueExportsSet];
-    const finalTypeExports = [...new Set(allTypeExports.filter((typeExport) => !finalValueExportsSet.has(typeExport)))];
+    const finalValueExports = [...valueExportsSet];
+    const finalTypeExports = [];
+    for (const typeExport of orderedTypeExports) {
+      if (!valueExportsSet.has(typeExport)) {
+        finalTypeExports.push(typeExport);
+      }
+    }
     const outputParts = [];
-    if (uniqueFileReferences.length > 0) {
-      outputParts.push(...uniqueFileReferences.map((ref) => `/// <reference path="${ref}" />`), "");
+    if (fileReferencesSet.size > 0) {
+      for (const ref of fileReferencesSet) {
+        outputParts.push(`/// <reference path="${ref}" />`);
+      }
+      outputParts.push("");
     }
-    if (uniqueTypeReferences.length > 0) {
-      outputParts.push(...uniqueTypeReferences.map((ref) => `/// <reference types="${ref}" />`), "");
+    if (typeReferencesSet.size > 0) {
+      for (const ref of typeReferencesSet) {
+        outputParts.push(`/// <reference types="${ref}" />`);
+      }
+      outputParts.push("");
     }
     if (mergedExternalImports.length > 0) {
-      outputParts.push(...mergedExternalImports, "");
+      for (const imp of mergedExternalImports) {
+        outputParts.push(imp);
+      }
+      outputParts.push("");
     }
     outputParts.push(codeBlocks.join(newLine + newLine));
     if (finalTypeExports.length > 0 || finalValueExports.length > 0) {
@@ -1399,18 +1471,26 @@ Total available files: ${availableFiles.length}`
   }
 };
 async function bundleDeclarations(options) {
-  if (!await Files.exists(options.compilerOptions.outDir)) {
-    await mkdir2(options.compilerOptions.outDir, defaultDirOptions);
-  }
+  await mkdir2(options.compilerOptions.outDir, defaultDirOptions);
   const dtsBundler = new DeclarationBundler(options);
-  await new Promise((resolve3) => void setImmediate(resolve3));
   const bundleTasks = [];
-  for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
+  const bundleEntryPoint = (entryName, entryPoint) => {
     const content = dtsBundler.bundle(entryPoint);
     if (content.length > 0) {
       const outPath = Paths.join(options.compilerOptions.outDir, `${entryName}${FileExtension.DTS}`);
       bundleTasks.push(writeFile2(outPath, content, Encoding.utf8).then(() => ({ path: Paths.relative(options.currentDirectory, outPath), size: content.length })));
     }
+  };
+  if (options.parallelTranspile) {
+    const queueImmediateTask = (resolve3) => void setImmediate(resolve3);
+    for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
+      await new Promise(queueImmediateTask);
+      bundleEntryPoint(entryName, entryPoint);
+    }
+  } else {
+    for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
+      bundleEntryPoint(entryName, entryPoint);
+    }
   }
   const results = await Promise.all(bundleTasks);
   dtsBundler.clearExternalFiles();
@@ -1574,12 +1654,12 @@ async function resolvePlugins(plugins, projectDir) {
 }
 
 // src/plugins/iife.ts
-import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, join, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+var namespace = "iife";
+var fileExtensionRegex = /\.[^.]+$/;
 var textDecoder = new TextDecoder();
-var jsExtension = ".js";
 function iifePlugin(options) {
-  const globalName = options?.globalName;
   const files = [];
   return {
     files,
@@ -1594,14 +1674,14 @@ function iifePlugin(options) {
         if (!outdir) {
           return;
         }
+        build.initialOptions.write = false;
         const sourcemap = build.initialOptions.sourcemap;
         const entryPointNames = extractEntryNames(build.initialOptions.entryPoints);
-        build.onEnd(async ({ metafile }) => {
-          if (!metafile || entryPointNames.length === 0) {
+        build.onEnd(async ({ outputFiles }) => {
+          if (!outputFiles || outputFiles.length === 0 || entryPointNames.length === 0) {
             return;
           }
-          const written = await buildIife(metafile.outputs, entryPointNames, outdir, globalName, sourcemap);
-          files.push(...written);
+          files.push(...await buildIife(outputFiles, entryPointNames, outdir, options?.globalName, sourcemap));
         });
       }
     }
@@ -1615,16 +1695,15 @@ function extractEntryNames(entryPoints) {
     const names = [];
     for (const entry of entryPoints) {
       if (typeof entry === "string") {
-        names.push(basename2(entry).replace(/\.[^.]+$/, ""));
+        names.push(basename2(entry).replace(fileExtensionRegex, ""));
       } else {
-        names.push(entry.out ?? basename2(entry.in).replace(/\.[^.]+$/, ""));
+        names.push(entry.out ?? basename2(entry.in).replace(fileExtensionRegex, ""));
       }
     }
     return names;
   }
   return Object.keys(entryPoints);
 }
-var namespace = "iife";
 function wrapAsIife(text, globalName) {
   const exportStart = text.lastIndexOf("export");
   if (exportStart === -1) {
@@ -1667,36 +1746,47 @@ ${text.slice(0, exportStart)}
 	${assignment}
 })();${text.slice(exportEnd)}`;
 }
-async function buildIife(outputs, entryPointNames, outdir, globalName, sourcemap) {
+async function buildIife(primaryOutputs, entryPointNames, outdir, globalName, sourcemap) {
   const { build: esbuild } = await import("esbuild");
   const fileContents = /* @__PURE__ */ new Map();
-  for (const outputPath of Object.keys(outputs)) {
-    if (outputPath.endsWith(jsExtension)) {
-      fileContents.set(resolve2(outputPath), await readFile2(outputPath, "utf8"));
+  const primaryWrites = [];
+  const ensuredDirs = /* @__PURE__ */ new Map();
+  for (const file of primaryOutputs) {
+    const absolute = resolve2(file.path);
+    if (absolute.endsWith(FileExtension.JS)) {
+      fileContents.set(absolute, file.text);
+    }
+    const dir = dirname2(absolute);
+    let dirReady = ensuredDirs.get(dir);
+    if (dirReady === void 0) {
+      dirReady = mkdir3(dir, { recursive: true });
+      ensuredDirs.set(dir, dirReady);
     }
+    primaryWrites.push(dirReady.then(() => writeFile3(absolute, file.contents)));
   }
   const validEntries = [];
   for (const name of entryPointNames) {
-    const path = Paths.absolute(outdir, name + jsExtension);
+    const path = Paths.absolute(outdir, name + FileExtension.JS);
     if (fileContents.has(path)) {
       validEntries.push({ name, path });
     }
   }
   if (validEntries.length === 0) {
+    await Promise.all(primaryWrites);
     return [];
   }
-  const hasSourceMap = sourcemap !== void 0 && sourcemap !== false;
+  const sourcemapValue = sourcemap !== void 0 && sourcemap !== false ? "external" : false;
   const plugins = [virtualLoaderPlugin(fileContents)];
-  const iifeOutdir = join(outdir, namespace);
+  const iifeOutdir = join2(outdir, namespace);
   await mkdir3(iifeOutdir, { recursive: true });
   const results = await Promise.all(validEntries.map(({ name, path }) => {
     return esbuild({
       entryPoints: { [name]: path },
       bundle: true,
-      format: "esm",
+      format,
       splitting: false,
       outdir: iifeOutdir,
-      sourcemap: hasSourceMap ? "external" : false,
+      sourcemap: sourcemapValue,
       write: false,
       logLevel: "warning",
       plugins
@@ -1705,24 +1795,25 @@ async function buildIife(outputs, entryPointNames, outdir, globalName, sourcemap
   const written = [];
   const writes = [];
   const cwd = process.cwd();
-  for (const { outputFiles: iifeFiles } of results) {
-    const outputFilePaths = new Set(iifeFiles.map(({ path }) => path));
-    for (const { path, contents } of iifeFiles) {
-      if (path.endsWith(jsExtension)) {
-        let text = wrapAsIife(textDecoder.decode(contents), globalName);
+  for (const { outputFiles } of results) {
+    const outputFilePaths = new Set(outputFiles.map(({ path }) => path));
+    for (const { path, contents } of outputFiles) {
+      let text, size = contents.byteLength;
+      if (path.endsWith(FileExtension.JS)) {
+        text = wrapAsIife(textDecoder.decode(contents), globalName);
         if (outputFilePaths.has(`${path}.map`)) {
           text += `
 //# sourceMappingURL=${basename2(path)}.map`;
+          size = Buffer.byteLength(text);
         }
-        writes.push(writeFile3(path, text));
-        written.push({ path: Paths.relative(cwd, path), size: Buffer.byteLength(text) });
       } else {
-        writes.push(writeFile3(path, contents));
-        written.push({ path: Paths.relative(cwd, path), size: contents.byteLength });
+        text = contents;
       }
+      writes.push(writeFile3(path, text));
+      written.push({ path: Paths.relative(cwd, path), size });
     }
   }
-  await Promise.all(writes);
+  await Promise.all([...writes, ...primaryWrites]);
   return written;
 }
 function virtualLoaderPlugin(fileContents) {
@@ -1741,10 +1832,7 @@ function virtualLoaderPlugin(fileContents) {
           return { external: true };
         }
         const resolved = resolve2(args.resolveDir, args.path);
-        if (fileContents.has(resolved)) {
-          return { path: resolved, namespace };
-        }
-        return { external: true };
+        return fileContents.has(resolved) ? { path: resolved, namespace } : { external: true };
       });
       build.onLoad({ filter: /.*/, namespace }, (args) => {
         const contents = fileContents.get(args.path);
@@ -1918,9 +2006,6 @@ _PerformanceLogger = __decorateElement(_init, 0, "PerformanceLogger", _Performan
 __runInitializers(_init, 1, _PerformanceLogger);
 var PerformanceLogger = _PerformanceLogger;
 var measure = new PerformanceLogger().measure;
-function addPerformanceStep(name, ms) {
-  pendingSteps.push({ name, duration: `${ms}ms`, ms });
-}
 
 // src/decorators/debounce.ts
 var _DebounceManager_decorators, _init2;
@@ -2053,20 +2138,34 @@ var FileManager = class {
    */
   finalize() {
     this.processEmittedFiles();
+    return this.cache === void 0 || this.hasEmittedFiles;
+  }
+  /**
+   * Persists the .tsbuildinfo file and the dts cache to disk in the background. Call this
+   * AFTER the build's parallel phases (transpile + dts bundling) have completed so the writes
+   * (and Brotli compression for the dts cache) don't compete with esbuild for libuv threadpool
+   * slots.
+   */
+  persistCache() {
     const tasks = [];
     if (this.pendingBuildInfo) {
       tasks.push(Files.write(this.pendingBuildInfo.path, this.pendingBuildInfo.text));
+      this.pendingBuildInfo = void 0;
     }
-    this.pendingBuildInfo = void 0;
-    if (this.cache && this.hasEmittedFiles) {
+    if (this.cache !== void 0 && this.hasEmittedFiles) {
       tasks.push(this.cache.save(this.declarationFiles));
     }
-    this.pendingSave = Promise.all(tasks).then(() => {
+    if (tasks.length === 0) {
+      return;
+    }
+    const save = tasks.length === 1 ? tasks[0].then(() => {
+    }, () => {
+    }) : Promise.all(tasks).then(() => {
     }, () => {
     });
-    this.pendingSave?.catch(() => {
+    this.pendingSave = this.pendingSave === void 0 ? save : Promise.all([this.pendingSave, save]).then(() => {
+    }, () => {
     });
-    return this.cache === void 0 || this.hasEmittedFiles;
   }
   /**
    * Retrieves all stored declaration files.
@@ -2195,13 +2294,21 @@ var FileManager = class {
 };
 
 // src/incremental-build-cache.ts
-import { rmSync } from "node:fs";
-var IncrementalBuildCache = class {
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+var IncrementalBuildCache = class _IncrementalBuildCache {
   buildInfoPath;
   cacheDirectoryPath;
   cacheFilePath;
+  outputsManifestPath;
   /** Pre-loading promise started in constructor for async cache restoration */
   cacheLoaded;
+  /**
+   * Manifest snapshot captured synchronously at construction. Held in memory so it survives
+   * `invalidate()` (which deletes the on-disk manifest as part of clearing `.tsbuild`) and so
+   * subsequent in-process reads are race-free.
+   */
+  outputsSnapshot;
   /** Set to true when invalidate() is called to prevent stale cache from being restored */
   invalidated = false;
   /**
@@ -2213,7 +2320,9 @@ var IncrementalBuildCache = class {
     this.buildInfoPath = Paths.join(projectRoot, tsBuildInfoFile);
     this.cacheDirectoryPath = Paths.join(projectRoot, cacheDirectory);
     this.cacheFilePath = Paths.join(this.cacheDirectoryPath, dtsCacheFile);
+    this.outputsManifestPath = Paths.join(this.cacheDirectoryPath, outputManifestFile);
     this.cacheLoaded = this.loadCache();
+    this.outputsSnapshot = _IncrementalBuildCache.loadOutputsSync(this.outputsManifestPath);
   }
   /**
    * Loads the cache file asynchronously using V8 deserialization.
@@ -2242,7 +2351,7 @@ var IncrementalBuildCache = class {
     if (cache === void 0) {
       return;
     }
-    for (const [fileName, content] of Object.entries(cache.files)) {
+    for (const [fileName, content] of cache.files) {
       target.set(fileName, content);
     }
   }
@@ -2252,7 +2361,39 @@ var IncrementalBuildCache = class {
    * @param source - The declaration files to cache
    */
   async save(source) {
-    await Files.writeCompressed(this.cacheFilePath, { version: dtsCacheVersion, files: Object.fromEntries(source) });
+    await Files.writeCompressed(this.cacheFilePath, { version: dtsCacheVersion, files: source });
+  }
+  /**
+   * Loads the previous build's output manifest synchronously.
+   * @param manifestPath - Absolute path to the manifest file
+   * @returns The recorded outputs, or undefined when missing/unreadable/malformed.
+   */
+  static loadOutputsSync(manifestPath) {
+    try {
+      const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+      return Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Returns the project-relative output paths recorded by the previous build, or undefined if none.
+   * The snapshot is captured at construction time and survives `invalidate()`.
+   * @returns The recorded outputs from the prior build, or undefined when unavailable.
+   */
+  getPreviousOutputs() {
+    return this.outputsSnapshot;
+  }
+  /**
+   * Persists the project-relative output paths produced by the current build.
+   * Updates the in-memory snapshot immediately so subsequent getPreviousOutputs() calls
+   * (in watch mode) return the freshly written list without re-reading disk.
+   * @param outputs - Project-relative output paths
+   */
+  async saveOutputs(outputs) {
+    this.outputsSnapshot = outputs.slice();
+    await mkdir4(this.cacheDirectoryPath, defaultDirOptions);
+    await writeFile4(this.outputsManifestPath, JSON.stringify(this.outputsSnapshot), "utf8");
   }
   /** Invalidates the build cache by removing the cache directory. */
   invalidate() {
@@ -2277,6 +2418,24 @@ var IncrementalBuildCache = class {
   isValid() {
     return !this.invalidated;
   }
+  /**
+   * Synchronously checks whether persisted incremental state exists on disk.
+   * When the .tsbuildinfo file is missing, the next typecheck will perform a full emit,
+   * making it safe to clean the output directory eagerly in parallel with type checking.
+   * @returns True when the .tsbuildinfo file is present and the cache hasn't been invalidated.
+   */
+  hasPersistedState() {
+    return !this.invalidated && existsSync(this.buildInfoPath);
+  }
+  /**
+   * Synchronously checks whether a manifest snapshot from a prior build is available.
+   * Survives `invalidate()` so the manifest-driven cleanup path can be used on
+   * `--clearCache` and `--force` runs as well.
+   * @returns True when an output manifest snapshot is held in memory.
+   */
+  hasPersistedManifest() {
+    return this.outputsSnapshot !== void 0;
+  }
   /**
    * Custom inspection tag for type.
    * @returns The string 'IncrementalBuildCache'
@@ -2311,8 +2470,7 @@ function outputToSourcePath(outputPath, outDir, sourceDir) {
   const relativePortion = normalizedOutput.slice(normalizedOutDir.length + 1);
   for (const [outExt, srcExt] of outputToSourceExtension) {
     if (relativePortion.endsWith(outExt)) {
-      const stem = relativePortion.slice(0, -outExt.length);
-      return `./${sourceDir}/${stem}${srcExt}`;
+      return `./${sourceDir}/${relativePortion.slice(0, -outExt.length)}${srcExt}`;
     }
   }
   return void 0;
@@ -2404,7 +2562,7 @@ var domPredicate = (lib) => lib.toUpperCase() === "DOM";
 var tsLogo = TextFormat.bgBlue(TextFormat.bold(TextFormat.whiteBright(" TS ")));
 var diagnosticsHost = { getNewLine: () => sys2.newLine, getCurrentDirectory: sys2.getCurrentDirectory, getCanonicalFileName: (fileName) => fileName };
 var _triggerRebuild_dec, _processDeclarations_dec, _transpile_dec, _typeCheck_dec, _build_dec, _TypeScriptProject_decorators, _init3;
-_TypeScriptProject_decorators = [closeOnExit], _build_dec = [measure("Build")], _typeCheck_dec = [measure("Type-checking")], _transpile_dec = [measure("Transpile", true)], _processDeclarations_dec = [measure("Bundle Declarations", true)], _triggerRebuild_dec = [debounce(100)];
+_TypeScriptProject_decorators = [closeOnExit], _build_dec = [measure("Build")], _typeCheck_dec = [measure("Type-checking/Emit", true)], _transpile_dec = [measure("Transpile", true)], _processDeclarations_dec = [measure("Bundle Declarations", true)], _triggerRebuild_dec = [debounce(100)];
 var _TypeScriptProject = class _TypeScriptProject {
   /**
    * Creates a TypeScript project and prepares it for building/bundling.
@@ -2421,6 +2579,9 @@ var _TypeScriptProject = class _TypeScriptProject {
     __publicField(this, "buildConfiguration");
     __publicField(this, "pendingChanges", []);
     __publicField(this, "buildDependencies", /* @__PURE__ */ new Set());
+    __publicField(this, "pendingStaleOutputsCleanup");
+    /** Identity of the Program that populated buildDependencies — skip re-walking when unchanged */
+    __publicField(this, "buildDependenciesProgram");
     __publicField(this, "dependencyPaths");
     this.directory = Paths.absolute(directory);
     this.configuration = _TypeScriptProject.resolveConfiguration(this.directory, options);
@@ -2431,6 +2592,10 @@ var _TypeScriptProject = class _TypeScriptProject {
     this.fileManager = new FileManager(buildCache);
     this.builderProgram = createIncrementalProgram({ rootNames, options: this.configuration.compilerOptions, projectReferences, configFileParsingDiagnostics });
     this.buildConfiguration = { entryPoints: this.getEntryPoints(entryPoints), target: toEsTarget(target), outDir, ...tsbuildOptions };
+    this.dependencyPaths = Files.read(Paths.absolute(this.directory, "package.json")).then((content) => {
+      const { dependencies = {}, peerDependencies = {} } = Json.parse(content);
+      return [.../* @__PURE__ */ new Set([...Object.keys(dependencies), ...Object.keys(peerDependencies)])];
+    }).catch(() => []);
   }
   /**
    * Cleans the output directory
@@ -2439,13 +2604,67 @@ var _TypeScriptProject = class _TypeScriptProject {
   async clean() {
     return Files.empty(this.buildConfiguration.outDir);
   }
+  /**
+   * Removes outputs that the previous build wrote but the current build did not — e.g. renamed
+   * entry points or content-hashed chunks whose hash changed. Restricted to files under outDir
+   * for safety. Fire-and-forget: scheduled after build completion so it never inflates timings.
+   * @param previous - Project-relative paths recorded by the previous build (or undefined)
+   * @param current - Project-relative paths produced by the current build
+   */
+  cleanupStaleOutputs(previous, current) {
+    if (previous === void 0 || previous.length === 0) {
+      return;
+    }
+    const currentSet = new Set(current);
+    const outDirRel = Paths.relative(this.directory, this.buildConfiguration.outDir);
+    const prefix = `${outDirRel}/`;
+    const stale = [];
+    for (const path of previous) {
+      if (currentSet.has(path)) {
+        continue;
+      }
+      if (path !== outDirRel && !path.startsWith(prefix)) {
+        continue;
+      }
+      stale.push(Paths.absolute(this.directory, path));
+    }
+    if (stale.length === 0) {
+      return;
+    }
+    const removals = new Array(stale.length);
+    for (let i = 0, length = stale.length; i < length; i++) {
+      removals[i] = rm2(stale[i], { force: true });
+    }
+    const cleanup = Promise.all(removals).then(() => void 0).catch(() => void 0).finally(() => {
+      if (this.pendingStaleOutputsCleanup === cleanup) {
+        this.pendingStaleOutputsCleanup = void 0;
+      }
+    });
+    this.pendingStaleOutputsCleanup = cleanup;
+  }
+  /**
+   * Waits for fire-and-forget stale-output cleanup to settle.
+   * Useful for deterministic tests that need to assert post-cleanup filesystem state.
+   */
+  async flushBackgroundCleanup() {
+    await this.pendingStaleOutputsCleanup;
+  }
   async build() {
-    Logger.header(`${tsLogo} tsbuild v${"1.8.6"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
+    Logger.header(`${tsLogo} tsbuild v${"1.8.8"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
     try {
       const processes = [];
+      const buildCache = this.configuration.buildCache;
+      const force = this.configuration.tsbuild.force;
+      const cleanEnabled = this.configuration.clean && !this.configuration.compilerOptions.noEmit;
+      const useManifest = cleanEnabled && buildCache !== void 0 && buildCache.hasPersistedManifest();
+      const previousOutputs = useManifest ? buildCache.getPreviousOutputs() : void 0;
+      const willEmit = force || buildCache?.hasPersistedState() !== true;
+      const eagerCleanPromise = cleanEnabled && willEmit && !useManifest ? this.clean() : void 0;
       const filesWereEmitted = await this.typeCheck();
-      if ((filesWereEmitted || this.configuration.tsbuild.force) && !this.configuration.compilerOptions.noEmit) {
-        if (this.configuration.clean) {
+      if ((filesWereEmitted || force) && !this.configuration.compilerOptions.noEmit) {
+        if (eagerCleanPromise !== void 0) {
+          await eagerCleanPromise;
+        } else if (cleanEnabled && !useManifest) {
           await this.clean();
         }
         if (this.configuration.compilerOptions.declaration) {
@@ -2454,20 +2673,41 @@ var _TypeScriptProject = class _TypeScriptProject {
         if (!this.configuration.compilerOptions.emitDeclarationOnly) {
           processes.push(this.transpile());
         }
+      } else if (eagerCleanPromise !== void 0) {
+        await eagerCleanPromise;
       }
-      for (const result of await Promise.allSettled(processes)) {
+      const settled = await Promise.allSettled(processes);
+      const newOutputs = [];
+      for (const result of settled) {
         if (result.status === "rejected") {
           this.handleBuildError(result.reason);
+          continue;
+        }
+        for (const { path } of result.value) {
+          newOutputs.push(path);
         }
       }
+      this.fileManager.persistCache();
+      if (buildCache !== void 0 && newOutputs.length > 0) {
+        if (previousOutputs !== void 0) {
+          this.cleanupStaleOutputs(previousOutputs, newOutputs);
+        }
+        void buildCache.saveOutputs(newOutputs).catch(() => {
+        });
+      }
     } catch (error) {
       this.handleBuildError(error);
     } finally {
       if (this.buildConfiguration.watch.enabled) {
-        this.buildDependencies.clear();
-        for (const { isDeclarationFile, fileName } of this.builderProgram.getProgram().getSourceFiles()) {
-          if (!isDeclarationFile) {
-            this.buildDependencies.add(Paths.relative(this.directory, fileName));
+        const program = this.builderProgram.getProgram();
+        if (this.buildDependenciesProgram !== program) {
+          this.buildDependenciesProgram = program;
+          this.buildDependencies.clear();
+          const dirWithSlash = this.directory + "/";
+          for (const { isDeclarationFile, fileName } of program.getSourceFiles()) {
+            if (!isDeclarationFile && fileName.startsWith(dirWithSlash)) {
+              this.buildDependencies.add(Paths.relative(this.directory, fileName));
+            }
           }
         }
         if (this.fileWatcher === void 0 || this.fileWatcher.isClosed()) {
@@ -2489,35 +2729,31 @@ var _TypeScriptProject = class _TypeScriptProject {
         ...this.builderProgram.getSemanticDiagnostics(),
         ...this.configuration.compilerOptions.declaration ? this.builderProgram.getDeclarationDiagnostics() : []
       ];
-      addPerformanceStep("Diagnostics", _TypeScriptProject.elapsed("diagnostics:start"));
-      performance2.mark("emit:start");
       this.builderProgram.emit(void 0, this.fileManager.fileWriter, void 0, true);
-      addPerformanceStep("Emit", _TypeScriptProject.elapsed("emit:start"));
     } else {
-      performance2.mark("emit:start");
       const { diagnostics } = this.builderProgram.emit(void 0, this.fileManager.fileWriter, void 0, true);
-      addPerformanceStep("Emit", _TypeScriptProject.elapsed("emit:start"));
-      performance2.mark("diagnostics:start");
       allDiagnostics = [...this.builderProgram.getSemanticDiagnostics(), ...diagnostics];
-      addPerformanceStep("Diagnostics", _TypeScriptProject.elapsed("diagnostics:start"));
     }
     if (allDiagnostics.length > 0) {
       _TypeScriptProject.handleTypeErrors("Type-checking failed", allDiagnostics, this.directory);
     }
-    performance2.mark("finalize:start");
-    const emitted = this.fileManager.finalize();
-    addPerformanceStep("Finalize", _TypeScriptProject.elapsed("finalize:start"));
-    return emitted || !this.configuration.compilerOptions.declaration;
+    return this.fileManager.finalize() || !this.configuration.compilerOptions.declaration;
   }
   async transpile() {
     const { build: esbuild, formatMessages } = await import("esbuild");
-    const plugins = [outputPlugin()];
+    const plugins = [];
+    let iife;
+    if (this.buildConfiguration.iife) {
+      iife = iifePlugin(this.buildConfiguration.iife === true ? void 0 : this.buildConfiguration.iife);
+      plugins.push(iife.plugin);
+    }
+    plugins.push(outputPlugin());
     if (this.buildConfiguration.noExternal.length > 0) {
       plugins.push(externalModulesPlugin({ dependencies: await this.getProjectDependencyPaths(), noExternal: this.buildConfiguration.noExternal }));
     }
     if (this.configuration.compilerOptions.emitDecoratorMetadata) {
       try {
-        const { swcDecoratorMetadataPlugin } = await import("./ZEGDBXXN.js");
+        const { swcDecoratorMetadataPlugin } = await import("./5DXLYKZU.js");
         plugins.push(swcDecoratorMetadataPlugin);
       } catch {
         throw new ConfigurationError("emitDecoratorMetadata is enabled but @swc/core is not installed. Install it with: pnpm add -D @swc/core");
@@ -2526,11 +2762,6 @@ var _TypeScriptProject = class _TypeScriptProject {
     if (this.buildConfiguration.plugins?.length) {
       plugins.push(...await resolvePlugins(this.buildConfiguration.plugins, this.directory));
     }
-    let iife;
-    if (this.buildConfiguration.iife) {
-      iife = iifePlugin(this.buildConfiguration.iife === true ? void 0 : this.buildConfiguration.iife);
-      plugins.push(iife.plugin);
-    }
     const define = {};
     if (this.buildConfiguration.env !== void 0) {
       const envExpansion = new RegExp(processEnvExpansionPattern, "g");
@@ -2626,7 +2857,9 @@ var _TypeScriptProject = class _TypeScriptProject {
   close() {
     this.fileWatcher?.close();
     this.fileManager.close();
+    this.pendingStaleOutputsCleanup = void 0;
     this.buildDependencies.clear();
+    this.buildDependenciesProgram = void 0;
     this.pendingChanges.length = 0;
   }
   async processDeclarations() {
@@ -2647,7 +2880,9 @@ var _TypeScriptProject = class _TypeScriptProject {
         rootDir: this.configuration.compilerOptions.rootDir,
         outDir: this.configuration.compilerOptions.outDir,
         moduleResolution: this.configuration.compilerOptions.moduleResolution
-      }
+      },
+      // Only yield to event loop if transpile is running in parallel
+      parallelTranspile: !this.configuration.compilerOptions.emitDeclarationOnly
     });
   }
   async triggerRebuild() {
@@ -2675,6 +2910,7 @@ var _TypeScriptProject = class _TypeScriptProject {
       }
     }
     this.pendingChanges.length = 0;
+    await this.fileManager.flush();
     this.builderProgram = createIncrementalProgram({ rootNames, options: this.configuration.compilerOptions, projectReferences: this.configuration.projectReferences, configFileParsingDiagnostics: this.configuration.configFileParsingDiagnostics });
     await this.build();
   }
@@ -2736,8 +2972,10 @@ var _TypeScriptProject = class _TypeScriptProject {
         ...{ outDir: defaultOutDirectory, noEmit: false, sourceMap: false, incremental: true, tsBuildInfoFile: Paths.join(cacheDirectory, buildInfoFile), lib: [] },
         ...configResult.config.compilerOptions,
         ...typeScriptOptions.compilerOptions,
-        // Always include 'node' and merge with any user-specified types
-        types: [.../* @__PURE__ */ new Set(["node", ...configResult.config.compilerOptions?.types ?? [], ...typeScriptOptions.compilerOptions?.types ?? []])]
+        // Auto-inject 'node' only on Node platform — browser/neutral builds shouldn't pay the
+        // cost of loading @types/node (~3 MB of declarations). Users can still opt in by
+        // listing 'node' explicitly in their tsconfig types array.
+        types: platform2 === Platform.NODE ? [.../* @__PURE__ */ new Set(["node", ...configResult.config.compilerOptions?.types ?? [], ...typeScriptOptions.compilerOptions?.types ?? []])] : [.../* @__PURE__ */ new Set([...configResult.config.compilerOptions?.types ?? [], ...typeScriptOptions.compilerOptions?.types ?? []])]
       }
     };
     const { options, fileNames, errors } = parseJsonConfigFileContent(baseConfig, sys2, directory);
@@ -2779,15 +3017,12 @@ var _TypeScriptProject = class _TypeScriptProject {
     return expandedEntryPoints;
   }
   /**
-   * Gets the project dependency paths, cached after first call.
-   * Reads package.json and caches it for reuse.
+   * Gets the project dependency paths.
+   * The promise is started in the constructor so it overlaps with TS Program creation.
    * @returns A promise that resolves to an array of project dependency paths.
    */
   getProjectDependencyPaths() {
-    return this.dependencyPaths ??= Files.read(Paths.absolute(this.directory, "package.json")).then((content) => {
-      const { dependencies = {}, peerDependencies = {} } = Json.parse(content);
-      return [.../* @__PURE__ */ new Set([...Object.keys(dependencies), ...Object.keys(peerDependencies)])];
-    });
+    return this.dependencyPaths;
   }
   /**
    * Handles build errors by logging unexpected errors and setting appropriate exit codes.