@d1g1tal/tsbuild 1.8.3 → 1.8.5

package/CHANGELOG.md

@@ -1,3 +1,47 @@
+## [1.8.5](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.4...v1.8.5) (2026-04-14)
+
+### Bug Fixes
+
+* **iife:** resolve paths absolutely and output to nested directory (7514592a039f02e070b71f4c30c6cd88a99bd17d)
+- Changes IIFE output to resolve paths absolutely instead of relatively
+- Creates a dedicated `iife` output directory under the main `outdir`
+- Fixes virtual loader plugin to handle the new directory structure properly
+- Adds an integration test for IIFE builds
+
+
+### Build System
+
+* **deps-dev:** bump typescript-eslint dependencies (e4abe9fe4083b89953f94f4cd17622387844b844)
+- Updates `@typescript-eslint/eslint-plugin`, `@typescript-eslint/parser`, and `typescript-eslint` from 8.58.1 to 8.58.2
+- Updates `pnpm-lock.yaml` with the new versions and their sub-dependencies
+
+## [1.8.4](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.3...v1.8.4) (2026-04-12)
+
+### Performance Improvements
+
+* **build:** delegate file writing to esbuild (84a64e212a9dc7f309bb2dcbe74ffa990c06065b)
+- Enables esbuild write option for direct-to-disk transpilation output
+- Moves relative module specifier rewriting logic to FileManager
+- Simplifies output plugin to only manage shebang executable permissions via chmod
+- Adapts IIFE plugin to process metafile outputs instead of in-memory files
+- Updates tests and mock helpers to align with file writing capabilities
+
+* **dts:** optimize declaration bundler module resolution and graph traversal (59606c0ccfe54ac74068fe6ab8f6d26d7edd97b6)
+- Optimizes module pattern matching by using Sets and RegEx arrays instead of iteration
+- Refactors bundled specifiers state to use ReadonlySet for O(1) lookups
+- Simplifies deduplication of non-mergeable imports using Sets
+- Yields the event loop before cpu-intensive declaration bundling to prevent I/O blocking
+
+
+### Miscellaneous Chores
+
+* **perf:** add performance baseline documentation and benchmark script (3e897aaa7a35022b8d9ec1d4222448973eb57a2b)
+- Adds documentation detailing performance baselines and architectures
+- Introduces performance measurements log
+- Adds quick reference for performance monitoring
+- Introduces new benchmark script for running automated metrics collection
+- Registers bench script in package.json
+
 ## [1.8.3](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.2...v1.8.3) (2026-04-11)
 
 ### Performance Improvements

package/dist/{UM2SFHAT.js → WCBM4DJB.js}

@@ -148,13 +148,13 @@ var isColorSupported = !("NO_COLOR" in env) && ("FORCE_COLOR" in env || platform
 var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => {
   return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
 };
-var clearBleed = (index, string, open, close, replace) => {
-  return index < 0 ? `${open}${string}${close}` : `${open}${replaceClose(index, string, close, replace)}${close}`;
+var clearBleed = (index, string, open2, close, replace) => {
+  return index < 0 ? `${open2}${string}${close}` : `${open2}${replaceClose(index, string, close, replace)}${close}`;
 };
-var filterEmpty = (open, close, replace = open, at = open.length + 1) => {
-  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open, close, replace) : "";
+var filterEmpty = (open2, close, replace = open2, at = open2.length + 1) => {
+  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open2, close, replace) : "";
 };
-var generateTextFormatter = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+var generateTextFormatter = (open2, close, replace) => filterEmpty(`\x1B[${open2}m`, `\x1B[${close}m`, replace);
 var TextFormat = class {
   static enabled = isColorSupported;
   static reset = generateTextFormatter(0, 0);
@@ -817,36 +817,40 @@ import {
   forEachChild as forEachChild2
 } 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 = [];
+  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}`;
-      if (!moduleImports.has(key)) {
-        moduleImports.set(key, { names: /* @__PURE__ */ new Set(), isType });
+      let entry = moduleImports.get(key);
+      if (entry === void 0) {
+        entry = { names: /* @__PURE__ */ new Set(), isType };
+        moduleImports.set(key, entry);
       }
-      const entry = moduleImports.get(key);
       for (const name of namesString.split(",")) {
         entry.names.add(name.trim());
       }
     } else {
-      nonMergeableImports.push(importStatement);
+      nonMergeableImports.add(importStatement);
     }
   }
   const result = [];
   for (const [key, { names, isType }] of moduleImports) {
     result.push(`${isType ? "import type" : "import"} { ${[...names].sort().join(", ")} } from "${key.replace(typePrefixPattern, "")}";`);
   }
-  result.push(...[...new Set(nonMergeableImports)]);
+  for (const imp of nonMergeableImports) {
+    result.push(imp);
+  }
   return result;
 }
-var DeclarationBundler = class {
+var DeclarationBundler = class _DeclarationBundler {
   /** Project declaration files from in-memory FileManager */
   declarationFiles = /* @__PURE__ */ new Map();
   /** External declaration files resolved from disk (node_modules) when resolve is enabled */
@@ -859,6 +863,10 @@ var DeclarationBundler = class {
   moduleResolutionCache = /* @__PURE__ */ new Map();
   /** Pre-computed set of directory prefixes from declaration file paths for O(1) directoryExists lookups */
   declarationDirs = /* @__PURE__ */ new Set();
+  /** Pre-built matcher for external patterns — O(1) string lookups + cached regex tests */
+  matchExternal;
+  /** Pre-built matcher for noExternal patterns — O(1) string lookups + cached regex tests */
+  matchNoExternal;
   // Create a proper module resolution host that supports both in-memory files and disk files
   moduleResolutionHost = {
     fileExists: (fileName) => {
@@ -908,6 +916,8 @@ var DeclarationBundler = class {
       }
     }
     this.options = dtsBundleOptions;
+    this.matchExternal = _DeclarationBundler.buildMatcher(dtsBundleOptions.external);
+    this.matchNoExternal = _DeclarationBundler.buildMatcher(dtsBundleOptions.noExternal);
   }
   /**
    * Clears external declaration files and module resolution cache to free memory.
@@ -960,23 +970,42 @@ var DeclarationBundler = class {
     return imports;
   }
   /**
-   * Check if a module specifier matches a pattern list
-   * @param moduleSpecifier - The module specifier to check
-   * @param patterns - Array of patterns to match against
-   * @returns True if the module matches any pattern
-   */
-  matchesPattern(moduleSpecifier, patterns) {
-    return patterns.some((pattern) => {
-      return typeof pattern === "string" ? moduleSpecifier === pattern || moduleSpecifier.startsWith(`${pattern}/`) : pattern.test(moduleSpecifier);
-    });
-  }
-  /**
-   * Check if a module specifier matches explicit external patterns
-   * @param moduleSpecifier - The module specifier to check
-   * @returns True if the module should be treated as external
+   * 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.
+   * @param patterns - The array of string and RegExp patterns to match against module specifiers
+   * @returns A function that takes a module specifier and returns true if it matches any of the patterns
    */
-  isExternal(moduleSpecifier) {
-    return this.matchesPattern(moduleSpecifier, this.options.external);
+  static buildMatcher(patterns) {
+    const exact = /* @__PURE__ */ new Set();
+    const prefixes = [];
+    const regexps = [];
+    for (const p of patterns) {
+      if (typeof p === "string") {
+        exact.add(p);
+        prefixes.push(p + "/");
+      } else {
+        regexps.push(p);
+      }
+    }
+    if (exact.size === 0 && regexps.length === 0) {
+      return () => false;
+    }
+    return (id) => {
+      if (exact.has(id)) {
+        return true;
+      }
+      for (let i = 0; i < prefixes.length; i++) {
+        if (id.startsWith(prefixes[i])) {
+          return true;
+        }
+      }
+      for (let i = 0; i < regexps.length; i++) {
+        if (regexps[i].test(id)) {
+          return true;
+        }
+      }
+      return false;
+    };
   }
   /**
    * Resolve a module import using TypeScript's resolution algorithm with path mapping support
@@ -1024,18 +1053,18 @@ var DeclarationBundler = class {
       const sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
       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 = [];
+      const bundledSpecs = /* @__PURE__ */ new Set();
       for (const specifier of this.extractImports(sourceFile)) {
-        if (this.isExternal(specifier)) {
+        if (this.matchExternal(specifier)) {
           continue;
         }
         const resolvedPath = this.resolveModule(specifier, path);
-        if (resolvedPath?.includes(nodeModules) && !this.matchesPattern(specifier, this.options.noExternal)) {
+        if (resolvedPath?.includes(nodeModules) && !this.matchNoExternal(specifier)) {
           continue;
         }
         if (resolvedPath && (this.declarationFiles.has(resolvedPath) || this.externalDeclarationFiles.has(resolvedPath))) {
           module.imports.add(resolvedPath);
-          bundledSpecs.push(specifier);
+          bundledSpecs.add(specifier);
           visit(resolvedPath);
         }
       }
@@ -1146,7 +1175,7 @@ var DeclarationBundler = class {
    * @param code - Declaration file content
    * @param sourceFile - Parsed source file AST (required to avoid re-parsing)
    * @param identifiers - Pre-computed type and value identifiers (to avoid re-computation)
-   * @param bundledImportPaths - Array of resolved file paths that were bundled (to exclude from external imports)
+   * @param bundledImportPaths - Set of resolved file paths that were bundled (to exclude from external imports)
    * @param renameMap - Map of renamed identifiers (name:path -> newName)
    * @param modulePath - Path of current module for looking up renames
    * @returns Object with processed code, collected external imports, and exported names (separated by type/value)
@@ -1169,7 +1198,7 @@ var DeclarationBundler = class {
     for (const statement of sourceFile.statements) {
       if (isImportDeclaration2(statement)) {
         const moduleSpecifier = statement.moduleSpecifier.text;
-        if (this.isExternal(moduleSpecifier) || !bundledImportPaths.includes(moduleSpecifier)) {
+        if (this.matchExternal(moduleSpecifier) || !bundledImportPaths.has(moduleSpecifier)) {
           externalImports.push(code.substring(statement.pos, statement.end).trim());
         } else if (statement.importClause?.namedBindings && isNamespaceImport(statement.importClause.namedBindings)) {
           bundledNamespaceAliases.add(statement.importClause.namedBindings.name.text);
@@ -1262,7 +1291,9 @@ var DeclarationBundler = class {
     for (const [name, sourcesSet] of declarationSources) {
       if (sourcesSet.size > 1) {
         let suffix = 1;
-        for (const modulePath of Array.from(sourcesSet).slice(1)) {
+        const modulePaths = sourcesSet.values();
+        modulePaths.next();
+        for (const modulePath of modulePaths) {
           let candidate = `${name}$${suffix}`;
           while (declarationSources.has(candidate)) {
             candidate = `${name}$${++suffix}`;
@@ -1275,7 +1306,7 @@ var DeclarationBundler = class {
     for (const { path, typeReferences, fileReferences, sourceFile, code, identifiers } of sortedModules) {
       allTypeReferences.push(...typeReferences);
       allFileReferences.push(...fileReferences);
-      const bundledForThisModule = bundledSpecifiers.get(path) || [];
+      const bundledForThisModule = bundledSpecifiers.get(path) ?? emptySet;
       const { code: strippedCode, externalImports, typeExports, valueExports } = this.stripImportsExports(code, sourceFile, identifiers, bundledForThisModule, renameMap, path);
       allExternalImports.push(...externalImports);
       if (!path.includes(nodeModules)) {
@@ -1372,11 +1403,12 @@ async function bundleDeclarations(options) {
     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 content = dtsBundler.bundle(entryPoint);
     if (content.length > 0) {
-      const outPath = Paths.join(options.compilerOptions.outDir, `${entryName}.d.ts`);
+      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 })));
     }
   }
@@ -1386,38 +1418,42 @@ async function bundleDeclarations(options) {
 }
 
 // src/plugins/output.ts
+import { chmod, open } from "node:fs/promises";
 import { extname } from "node:path";
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-var localFileIdentifier = /\.[a-z]+$/i;
-var relativeSpecifierPattern = /(from\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
-var FileMode = { READ_WRITE: 438, READ_WRITE_EXECUTE: 493 };
-function rewriteRelativeSpecifiers(code) {
-  return code.replace(relativeSpecifierPattern, (_, before, path, after) => localFileIdentifier.test(path) ? before + path + after : `${before}${path}.js${after}`);
-}
-async function fileMapper({ path, contents }) {
-  if (extname(path) !== FileExtension.JS) {
-    return Files.write(path, contents, { mode: FileMode.READ_WRITE });
-  }
-  let rewritten = false;
-  const result = textDecoder.decode(contents).replace(relativeSpecifierPattern, (_, before, specPath, after) => {
-    if (localFileIdentifier.test(specPath)) {
-      return before + specPath + after;
+async function setShebangPermissions(filePath) {
+  const handle = await open(filePath, "r");
+  try {
+    const buf = Buffer.alloc(2);
+    await handle.read(buf, 0, 2, 0);
+    if (buf[0] === 35 && buf[1] === 33) {
+      await chmod(filePath, 493);
     }
-    rewritten = true;
-    return `${before}${specPath}.js${after}`;
-  });
-  return Files.write(path, rewritten ? textEncoder.encode(result) : contents, { mode: contents[0] === 35 && contents[1] === 33 ? FileMode.READ_WRITE_EXECUTE : FileMode.READ_WRITE });
+  } finally {
+    await handle.close();
+  }
 }
 var outputPlugin = () => {
   return {
     name: "esbuild:output-plugin",
     /**
-     * Configures the esbuild build instance to write output files to disk
+     * Checks JS entry points for shebangs and sets executable permissions
      * @param build The esbuild build instance
      */
     setup(build) {
-      build.onEnd(async ({ outputFiles }) => void await Promise.all(outputFiles.map(fileMapper)));
+      build.onEnd(async ({ metafile }) => {
+        if (!metafile) {
+          return;
+        }
+        const tasks = [];
+        for (const [outputPath, { entryPoint }] of Object.entries(metafile.outputs)) {
+          if (entryPoint && extname(outputPath) === FileExtension.JS) {
+            tasks.push(setShebangPermissions(outputPath));
+          }
+        }
+        if (tasks.length > 0) {
+          await Promise.all(tasks);
+        }
+      });
     }
   };
 };
@@ -1538,9 +1574,9 @@ async function resolvePlugins(plugins, projectDir) {
 }
 
 // src/plugins/iife.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+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";
-var textDecoder2 = new TextDecoder();
+var textDecoder = new TextDecoder();
 var jsExtension = ".js";
 function iifePlugin(options) {
   const globalName = options?.globalName;
@@ -1560,11 +1596,11 @@ function iifePlugin(options) {
         }
         const sourcemap = build.initialOptions.sourcemap;
         const entryPointNames = extractEntryNames(build.initialOptions.entryPoints);
-        build.onEnd(async ({ outputFiles }) => {
-          if (!outputFiles?.length || entryPointNames.length === 0) {
+        build.onEnd(async ({ metafile }) => {
+          if (!metafile || entryPointNames.length === 0) {
             return;
           }
-          const written = await buildIife(outputFiles, entryPointNames, outdir, globalName, sourcemap);
+          const written = await buildIife(metafile.outputs, entryPointNames, outdir, globalName, sourcemap);
           files.push(...written);
         });
       }
@@ -1590,6 +1626,7 @@ function extractEntryNames(entryPoints) {
 }
 var exportRegex = /export\s*\{([^}]*)\};?/g;
 var exportAliasRegex = /^(\w+)\s+as\s+(\w+)$/;
+var namespace = "iife";
 function wrapAsIife(text, globalName) {
   const exportIndex = text.lastIndexOf("export");
   if (exportIndex === -1) {
@@ -1620,31 +1657,30 @@ ${body}
 	${assignment}
 })();${after}`;
 }
-async function buildIife(outputFiles, entryPointNames, outdir, globalName, sourcemap) {
+async function buildIife(outputs, entryPointNames, outdir, globalName, sourcemap) {
   const { build: esbuild } = await import("esbuild");
   const fileContents = /* @__PURE__ */ new Map();
-  for (const { path, contents } of outputFiles) {
-    if (path.endsWith(jsExtension)) {
-      fileContents.set(path, textDecoder2.decode(contents));
+  for (const outputPath of Object.keys(outputs)) {
+    if (outputPath.endsWith(jsExtension)) {
+      fileContents.set(resolve2(outputPath), await readFile2(outputPath, "utf8"));
     }
   }
   const validEntries = [];
   for (const name of entryPointNames) {
-    const absPath = join(outdir, name + jsExtension);
-    if (fileContents.has(absPath)) {
-      validEntries.push({ name, absPath });
+    const path = Paths.absolute(outdir, name + jsExtension);
+    if (fileContents.has(path)) {
+      validEntries.push({ name, path });
     }
   }
   if (validEntries.length === 0) {
     return [];
   }
   const hasSourceMap = sourcemap !== void 0 && sourcemap !== false;
-  const iifeOutdir = join(outdir, "iife");
-  const loaderPlugin = virtualLoaderPlugin(fileContents);
-  await mkdir3(iifeOutdir, { recursive: true });
-  const results = await Promise.all(validEntries.map(
-    ({ name, absPath }) => esbuild({
-      entryPoints: { [name]: absPath },
+  const plugins = [virtualLoaderPlugin(fileContents)];
+  const iifeOutdir = await mkdir3(join(outdir, namespace), { recursive: true });
+  const results = await Promise.all(validEntries.map(({ name, path }) => {
+    return esbuild({
+      entryPoints: { [name]: path },
       bundle: true,
       format: "esm",
       splitting: false,
@@ -1652,16 +1688,16 @@ async function buildIife(outputFiles, entryPointNames, outdir, globalName, sourc
       sourcemap: hasSourceMap ? "external" : false,
       write: false,
       logLevel: "warning",
-      plugins: [loaderPlugin]
-    })
-  ));
+      plugins
+    });
+  }));
   const written = [];
   const writes = [];
   const cwd = process.cwd();
   for (const { outputFiles: iifeFiles } of results) {
     for (const { path, contents } of iifeFiles) {
       if (path.endsWith(jsExtension)) {
-        const text = wrapAsIife(textDecoder2.decode(contents), globalName);
+        const text = wrapAsIife(textDecoder.decode(contents), globalName);
         writes.push(writeFile3(path, text));
         written.push({ path: Paths.relative(cwd, path), size: Buffer.byteLength(text) });
       } else {
@@ -1683,23 +1719,20 @@ function virtualLoaderPlugin(fileContents) {
     setup(build) {
       build.onResolve({ filter: /.*/ }, (args) => {
         if (args.kind === "entry-point") {
-          return { path: args.path, namespace: "iife" };
+          return { path: args.path, namespace };
         }
         if (!args.path.startsWith(".") && !args.path.startsWith("/")) {
           return { external: true };
         }
         const resolved = resolve2(args.resolveDir, args.path);
         if (fileContents.has(resolved)) {
-          return { path: resolved, namespace: "iife" };
+          return { path: resolved, namespace };
         }
         return { external: true };
       });
-      build.onLoad({ filter: /.*/, namespace: "iife" }, (args) => {
+      build.onLoad({ filter: /.*/, namespace }, (args) => {
         const contents = fileContents.get(args.path);
-        if (contents !== void 0) {
-          return { contents, loader: "js", resolveDir: dirname2(args.path) };
-        }
-        return null;
+        return contents === void 0 ? null : { contents, loader: "js", resolveDir: dirname2(args.path) };
       });
     }
   };
@@ -1941,6 +1974,11 @@ function debounce(wait) {
 
 // src/file-manager.ts
 import { createSourceFile as createSourceFile2, ScriptTarget as ScriptTarget2 } from "typescript";
+var localFileIdentifier = /\.[a-z]+$/i;
+var relativeSpecifierPattern = /(from\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
+function rewriteRelativeSpecifiers(code) {
+  return code.replace(relativeSpecifierPattern, (_, before, path, after) => localFileIdentifier.test(path) ? before + path + after : `${before}${path}.js${after}`);
+}
 var FileManager = class {
   hasEmittedFiles = false;
   declarationFiles = /* @__PURE__ */ new Map();
@@ -1999,14 +2037,17 @@ var FileManager = class {
    */
   finalize() {
     this.processEmittedFiles();
-    const buildInfoWrite = this.pendingBuildInfo ? Files.write(this.pendingBuildInfo.path, this.pendingBuildInfo.text) : void 0;
+    const tasks = [];
+    if (this.pendingBuildInfo) {
+      tasks.push(Files.write(this.pendingBuildInfo.path, this.pendingBuildInfo.text));
+    }
     this.pendingBuildInfo = void 0;
     if (this.cache && this.hasEmittedFiles) {
-      this.pendingSave = Promise.all([buildInfoWrite, this.cache.save(this.declarationFiles)]).then(() => {
-      });
-    } else if (buildInfoWrite) {
-      this.pendingSave = buildInfoWrite;
+      tasks.push(this.cache.save(this.declarationFiles));
     }
+    this.pendingSave = Promise.all(tasks).then(() => {
+    }, () => {
+    });
     this.pendingSave?.catch(() => {
     });
     return this.cache === void 0 || this.hasEmittedFiles;
@@ -2038,7 +2079,7 @@ var FileManager = class {
         writeTasks.push(this.writeFile(projectDirectory, filePath, code));
       }
     }
-    return (await Promise.all(writeTasks)).filter((result) => result !== void 0);
+    return Promise.all(writeTasks);
   }
   /**
    * Resolves entry points for declaration bundling.
@@ -2383,7 +2424,7 @@ var _TypeScriptProject = class _TypeScriptProject {
     return Files.empty(this.buildConfiguration.outDir);
   }
   async build() {
-    Logger.header(`${tsLogo} tsbuild v${"1.8.3"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
+    Logger.header(`${tsLogo} tsbuild v${"1.8.5"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
     try {
       const processes = [];
       const filesWereEmitted = await this.typeCheck();
@@ -2486,7 +2527,7 @@ var _TypeScriptProject = class _TypeScriptProject {
         format,
         plugins,
         define,
-        write: false,
+        write: true,
         metafile: true,
         treeShaking: true,
         logLevel: "warning",

package/dist/tsbuild.js

@@ -2,7 +2,7 @@
 import {
   BuildError,
   TypeScriptProject
-} from "./UM2SFHAT.js";
+} from "./WCBM4DJB.js";
 import "./JKGYA2AW.js";
 
 // src/tsbuild.ts
@@ -30,7 +30,7 @@ if (help) {
   process.exit(0);
 }
 if (version) {
-  console.log("1.8.3");
+  console.log("1.8.5");
   process.exit(0);
 }
 var typeScriptOptions = {

package/dist/type-script-project.js

@@ -1,6 +1,6 @@
 import {
   TypeScriptProject
-} from "./UM2SFHAT.js";
+} from "./WCBM4DJB.js";
 import "./JKGYA2AW.js";
 export {
   TypeScriptProject

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d1g1tal/tsbuild",
   "author": "D1g1talEntr0py",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "license": "MIT",
   "description": "A fast, ESM-only TypeScript build tool combining the TypeScript API for type checking and declaration generation, esbuild for bundling, and SWC for decorator metadata.",
   "homepage": "https://github.com/D1g1talEntr0py/tsbuild#readme",
@@ -51,8 +51,8 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^25.6.0",
-    "@typescript-eslint/eslint-plugin": "^8.58.1",
-    "@typescript-eslint/parser": "^8.58.1",
+    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/parser": "^8.58.2",
     "@vitest/coverage-v8": "^4.1.4",
     "eslint": "^10.2.0",
     "eslint-plugin-jsdoc": "^62.9.0",
@@ -60,7 +60,7 @@
     "memfs": "^4.57.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.1",
+    "typescript-eslint": "^8.58.2",
     "vitest": "^4.1.4"
   },
   "peerDependencies": {
@@ -81,6 +81,7 @@
   "scripts": {
     "build": "tsx ./src/tsbuild.ts",
     "build:watch": "tsx ./src/tsbuild.ts --watch",
+    "bench": "tsx ./scripts/benchmark.ts",
     "type-check": "tsx ./src/tsbuild.ts --noEmit",
     "lint": "eslint ./src",
     "test": "vitest run",