@bunup/dts 0.11.19

package/README.md

@@ -0,0 +1,56 @@
+# typeroll
+
+A blazing-fast `.d.ts` bundler written in Bun, designed to generate and merge TypeScript declarations from an entry point into a single `index.d.ts`, with advanced features like splitting and minification.
+
+Typeroll powers [Bunup's TypeScript declarations feature](https://bunup.dev/docs/guide/typescript-declarations). Learn more at [bunup.dev](https://bunup.dev/).
+
+## How It Works
+
+Typeroll leverages **Bun's native bundler** under the hood to achieve blazing-fast TypeScript declaration bundling. Since Bun's bundler is designed for JavaScript and outputs JavaScript (not built for types or `.d.ts` files), we employ some clever tricks to make Bun bundle TypeScript declarations while supporting advanced features like code splitting and minification.
+
+### The Process
+
+**1. Declaration Generation**
+
+First, `typeroll` generates `.d.ts` files from TypeScript sources using **isolated declarations** via `oxc-transform`.
+
+**2. FakeJS Transformation**
+
+Here's where the magic happens: we convert `.d.ts` files into synthetic JavaScript modules ("FakeJS"). Each type declaration becomes a **token array** where:
+- Type content is broken down into individual tokens
+- **Identifiers are preserved as live JavaScript variables** (not strings)
+- The array variable name matches the original type name
+
+```javascript
+// Original TypeScript declaration:
+export interface UserProfile extends BaseUser {
+  name: string;
+  age: number;
+}
+
+// Transformed to FakeJS:
+export var UserProfile = [
+  "interface", UserProfile, "extends", BaseUser, "{",
+  "name", ":", "string", ";",
+  "age", ":", "number", ";",
+  "}"
+];
+```
+
+**3. Bundling with Bun**
+
+Bun treats these FakeJS modules as regular JavaScript, enabling it to:
+- **Track usage** of types through variable references
+- Apply **tree-shaking** to remove unused types
+- Perform **code splitting** when shared types are detected
+- Apply **name mangling** during minification
+
+The key insight: since identifiers are live variables, when Bun renames a variable during minification, it automatically updates **all references** throughout the bundle.
+
+**4. Rehydration**
+
+After bundling, we convert the Bun-bundled FakeJS back to clean `.d.ts` declarations. The beauty is that any name mangling applied by Bun is perfectly preserved—if Bun renamed `UserInterface` to `a`, all references are consistently updated.
+
+### The Result
+
+This round-trip transformation gives us the best of both worlds: the performance and advanced features of Bun's JavaScript bundler applied to TypeScript declarations, resulting in optimized, tree-shaken, and properly split `.d.ts` files without relying on TypeScript's own emit pipeline.

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+import { OxcError } from "oxc-transform";
+type IsolatedDeclarationError = {
+	error: OxcError
+	file: string
+	content: string
+};
+declare function logIsolatedDeclarationErrors(errors: IsolatedDeclarationError[]): void;
+type Naming = string | {
+	chunk: string
+};
+type Resolve = boolean | (string | RegExp)[];
+/**
+* Options for generating declaration file
+*/
+type GenerateDtsOptions = {
+	naming?: Naming
+	/**
+	* Path to the preferred tsconfig.json file
+	* By default, the closest tsconfig.json file will be used
+	*/
+	preferredTsConfigPath?: string
+	/**
+	* Controls which external modules should be resolved
+	* - `true` to resolve all external modules
+	* - Array of strings or RegExp to match specific modules
+	* - `false` or `undefined` to disable external resolution
+	*/
+	resolve?: Resolve
+	/**
+	* The directory where the plugin will look for the `tsconfig.json` file and `node_modules`
+	* By default, the current working directory will be used
+	*/
+	cwd?: string
+	/**
+	* Whether to split declaration files when multiple entrypoints import the same files,
+	* modules, or share types. When enabled, shared types will be extracted to separate
+	* .d.ts files, and other declaration files will import these shared files.
+	*
+	* This helps reduce bundle size by preventing duplication of type definitions
+	* across multiple entrypoints.
+	*/
+	splitting?: boolean
+	/**
+	* Whether to minify the generated declaration files to reduce the size of the declaration file.
+	*/
+	minify?: boolean
+};
+type GenerateDtsResultFile = {
+	/**
+	* The kind of declaration file.
+	* - 'entry-point': The declaration file for an entry point
+	* - 'chunk': A declaration file created when code splitting is enabled
+	*/
+	kind: "entry-point" | "chunk"
+	/**
+	* The entry point that was used to generate the declaration file.
+	*
+	* This will only be available if the kind is 'entry-point' and not for chunk declaration files.
+	*/
+	entrypoint: string | undefined
+	/**
+	* If the kind is 'chunk', this is the name of the chunk file.
+	*/
+	chunkFileName: string | undefined
+	/**
+	* The output path of the declaration file relative to the output directory.
+	* This is the directory where you want to save the declaration file.
+	* When saving the declaration file, you should use this path to save it
+	* in the output directory you decide.
+	*
+	* This is particularly useful when splitting is enabled, as some declaration
+	* files import chunk files. Saving to this path ensures the import paths
+	* are correct.
+	*
+	* This is the recommended approach when saving declaration files to the
+	* output directory.
+	*
+	* @example
+	* await Bun.write(`dist/${result.outputPath}`, result.dts)
+	*/
+	outputPath: string
+	/**
+	* The parsed parts of the output path, containing the file name and extension
+	* This is useful when you need to manipulate the file name or extension separately
+	*/
+	pathInfo: {
+		/** The output path relative to the output directory without the extension */
+		outputPathWithoutExtension: string
+		/** The file extension including the dot (e.g. '.d.ts') */
+		ext: string
+	}
+	/**
+	* The generated declaration file
+	*/
+	dts: string
+};
+/**
+* Result of the generateDts function
+*/
+type GenerateDtsResult = {
+	/**
+	* The generated declaration files with their relevant information
+	*/
+	files: GenerateDtsResultFile[]
+	/**
+	* The errors that occurred during the generation
+	*/
+	errors: IsolatedDeclarationError[]
+};
+declare function generateDts(entrypoints: string[], options?: GenerateDtsOptions): Promise<GenerateDtsResult>;
+export { logIsolatedDeclarationErrors, generateDts, IsolatedDeclarationError, GenerateDtsResult, GenerateDtsOptions };

package/dist/index.js

@@ -0,0 +1,694 @@
+// packages/dts/src/generate.ts
+import path from "node:path";
+import { isolatedDeclaration } from "oxc-transform";
+import { resolveTsImportPath } from "ts-import-resolver";
+
+// packages/dts/src/constants.ts
+var EMPTY_EXPORT = "export {};";
+
+// packages/dts/src/errors.ts
+class TyperollError extends Error {
+  constructor(message) {
+    super(`typeroll: ${message}`);
+  }
+}
+
+// packages/dts/src/fake-js.ts
+import { parse } from "@babel/parser";
+
+// packages/dts/src/re.ts
+var IMPORT_TYPE_RE = /import\s+type\s+/g;
+var EXPORT_TYPE_RE = /export\s+type\s+/g;
+var IMPORT_EXPORT_NAMES_RE = /(import|export)\s*{([^}]*)}/g;
+var IMPORT_EXPORT_WITH_DEFAULT_RE = /(import|export)(\s+[^{,]+,)?\s*{([^}]*)}/g;
+var TYPE_WORD_RE = /\btype\s+/g;
+var EXPORT_DEFAULT_RE = /\bexport\s+default\s+/g;
+var EXPORT_RE = /\bexport\s+/g;
+var TOKENIZE_RE = /(\s+|\/\/.*?(?:\n|$)|\/\*[\s\S]*?\*\/|[a-zA-Z_$][a-zA-Z0-9_$]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|[(){}[\],.;:]|=>|&&|\|\||[=!<>]=?|\+\+|--|[-+*/%&|^!~?]|\.{3}|::|\.)/g;
+var CAPITAL_LETTER_RE = /[A-Z]/;
+var JS_RE = /\.[cm]?jsx?$/;
+var TS_RE = /\.[cm]?tsx?$|\.d\.[cm]?ts$/;
+var EXTENSION_REGEX = /\.(d\.(ts|cts|mts)|[cm]?[jt]s)$/;
+var NODE_MODULES_RE = /node_modules/;
+
+// packages/dts/src/ast.ts
+function isLikelyVariableOrTypeName(token) {
+  return CAPITAL_LETTER_RE.test(token) && !token.startsWith("/*") && !token.startsWith("@") && !token.startsWith('"') && !token.startsWith("'") && !token.startsWith("`");
+}
+function isImportDeclaration(node) {
+  return node.type === "ImportDeclaration";
+}
+function removeExportSyntaxes(text) {
+  return text.replace(EXPORT_DEFAULT_RE, "").replace(EXPORT_RE, "");
+}
+function isExportAllDeclaration(node) {
+  return node.type === "ExportAllDeclaration";
+}
+function isReExportStatement(node) {
+  return node.type === "ExportNamedDeclaration" && !node.declaration;
+}
+function isSideEffectImport(node) {
+  return node.type === "ImportDeclaration" && node.specifiers.length === 0;
+}
+function hasExportModifier(node, text) {
+  return node.type.startsWith("Export") || text.trim().startsWith("export");
+}
+function hasDefaultExportModifier(node, text) {
+  return node.type === "ExportDefaultDeclaration" || text.trim().startsWith("export default");
+}
+function isDefaultReExport(node) {
+  return node.type === "ExportDefaultDeclaration" && node.declaration?.type === "Identifier";
+}
+function getName(node, source) {
+  if (!node)
+    return null;
+  if (node.type === "ExportNamedDeclaration" && node.declaration) {
+    return getName(node.declaration, source);
+  }
+  if (node.type === "ExportDefaultDeclaration" && node.declaration) {
+    if (node.declaration.type === "Identifier") {
+      return node.declaration.name;
+    }
+    return getName(node.declaration, source);
+  }
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "ClassDeclaration":
+    case "TSEnumDeclaration":
+    case "FunctionDeclaration":
+    case "TSDeclareFunction":
+      if (node.id && node.id.type === "Identifier") {
+        return node.id.name;
+      }
+      break;
+    case "TSModuleDeclaration":
+      if (node.id && node.id.type === "Identifier") {
+        return node.id.name;
+      }
+      break;
+    case "VariableDeclaration": {
+      const declarations = node.declarations;
+      if (declarations?.length === 1 && declarations[0].id?.type === "Identifier") {
+        return declarations[0].id.name;
+      }
+      break;
+    }
+  }
+  return null;
+}
+function getCommentText(comments) {
+  if (!comments)
+    return null;
+  return comments.map((comment) => {
+    return comment.type === "CommentBlock" ? `/*${comment.value}*/` : comment.type === "CommentLine" ? `//${comment.value}` : null;
+  }).join(`
+`);
+}
+function getAllImportNames(body) {
+  const importNames = [];
+  for (const statement of body) {
+    if (isImportDeclaration(statement)) {
+      const importDecl = statement;
+      if (importDecl.specifiers) {
+        for (const specifier of importDecl.specifiers) {
+          if (specifier.type === "ImportDefaultSpecifier") {
+            importNames.push(specifier.local.name);
+          } else if (specifier.type === "ImportSpecifier") {
+            importNames.push(specifier.local.name);
+          } else if (specifier.type === "ImportNamespaceSpecifier") {
+            importNames.push(specifier.local.name);
+          }
+        }
+      }
+    }
+  }
+  return importNames;
+}
+
+// packages/dts/src/utils.ts
+import { existsSync } from "node:fs";
+import { normalize } from "node:path";
+import { loadConfig } from "coffi";
+import { minify } from "oxc-minify";
+import { isCI, isDevelopment } from "std-env";
+function isTypeScriptFile(path) {
+  if (!path)
+    return false;
+  return TS_RE.test(path);
+}
+function returnPathIfExists(path) {
+  return existsSync(path) ? path : null;
+}
+function getExtension(filename) {
+  const match = filename.match(EXTENSION_REGEX);
+  if (!match)
+    return "";
+  const ext = match[0];
+  return ext;
+}
+function replaceExtension(filename, newExt) {
+  if (EXTENSION_REGEX.test(filename)) {
+    return filename.replace(EXTENSION_REGEX, newExt);
+  }
+  return filename + newExt;
+}
+function deleteExtension(filename) {
+  return filename.replace(EXTENSION_REGEX, "");
+}
+async function loadTsConfig(cwd, preferredPath) {
+  const config = await loadConfig({
+    name: "tsconfig",
+    extensions: [".json"],
+    preferredPath,
+    cwd
+  });
+  return config;
+}
+function getShortFilePath(filePath, maxLength = 3) {
+  const fileParts = filePath.split("/");
+  const shortPath = fileParts.slice(-maxLength).join("/");
+  return shortPath;
+}
+function generateRandomString(length = 10) {
+  return Array.from({ length }, () => String.fromCharCode(97 + Math.floor(Math.random() * 26))).join("");
+}
+function isDev() {
+  return isDevelopment || !isCI;
+}
+function isNullOrUndefined(value) {
+  return value === undefined || value === null;
+}
+function cleanPath(path) {
+  let cleaned = normalize(path).replace(/\\/g, "/");
+  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
+  cleaned = cleaned.replace(/^\/+/, "");
+  cleaned = cleaned.replace(/\/+/g, "/");
+  return cleaned;
+}
+function getDeclarationExtensionFromJsExtension(ext) {
+  if (ext === ".mjs")
+    return ".d.mts";
+  if (ext === ".cjs")
+    return ".d.cts";
+  return ".d.ts";
+}
+async function getFilesFromGlobs(patterns, cwd) {
+  const includePatterns = patterns.filter((p) => !p.startsWith("!"));
+  const excludePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  const includedFiles = new Set;
+  for (const pattern of includePatterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan(cwd)) {
+      includedFiles.add(file);
+    }
+  }
+  if (excludePatterns.length > 0) {
+    for (const pattern of excludePatterns) {
+      const glob = new Bun.Glob(pattern);
+      for await (const file of glob.scan(cwd)) {
+        includedFiles.delete(file);
+      }
+    }
+  }
+  return Array.from(includedFiles);
+}
+function filterTypescriptFiles(files) {
+  return files.filter((file) => isTypeScriptFile(file));
+}
+function minifyDts(dts) {
+  return minify(`${generateRandomString()}.d.ts`, dts, {
+    codegen: {
+      removeWhitespace: true
+    },
+    mangle: false,
+    compress: false,
+    sourcemap: false
+  }).code;
+}
+
+// packages/dts/src/fake-js.ts
+async function dtsToFakeJs(dtsContent) {
+  const parsed = parse(dtsContent, {
+    sourceType: "module",
+    plugins: ["typescript"]
+  });
+  const referencedNames = new Set;
+  const exportedNames = new Set;
+  const result = [];
+  for (const name of getAllImportNames(parsed.program.body)) {
+    referencedNames.add(name);
+  }
+  for (const statement of parsed.program.body) {
+    if (isNullOrUndefined(statement.start) || isNullOrUndefined(statement.end)) {
+      continue;
+    }
+    const statementText = dtsContent.substring(statement.start, statement.end);
+    const name = getName(statement, dtsContent);
+    if (name) {
+      referencedNames.add(name);
+    }
+    const isDefaultExport = hasDefaultExportModifier(statement, statementText);
+    if (isDefaultExport) {
+      result.push(`export { ${name} as default };`);
+      if (isDefaultReExport(statement)) {
+        continue;
+      }
+    }
+    if (isImportDeclaration(statement) || isExportAllDeclaration(statement) || isReExportStatement(statement)) {
+      if (isSideEffectImport(statement)) {
+        continue;
+      }
+      const jsImportExport = jsifyImportExport(statementText);
+      result.push(jsImportExport);
+      continue;
+    }
+    let leadingComment = null;
+    leadingComment = getCommentText(statement.leadingComments);
+    let statementTextWithCommentsAttatched = `${leadingComment ? `${leadingComment}
+` : ""}${statementText}`;
+    const isExported = hasExportModifier(statement, statementText);
+    if (isExported) {
+      statementTextWithCommentsAttatched = removeExportSyntaxes(statementTextWithCommentsAttatched);
+    }
+    const tokens = tokenizeText(statementTextWithCommentsAttatched, referencedNames);
+    const varName = name || generateRandomString();
+    result.push(`var ${varName} = [${tokens.join(", ")}];`);
+    if (isExported && !isDefaultExport && !exportedNames.has(varName)) {
+      result.push(`export { ${varName} };`);
+      exportedNames.add(varName);
+    }
+  }
+  return result.join(`
+`);
+}
+async function fakeJsToDts(fakeJsContent) {
+  const parseResult = parse(fakeJsContent, {
+    sourceType: "module",
+    attachComment: false
+  });
+  const program = parseResult.program;
+  const resultParts = [];
+  for (const statement of program.body) {
+    if (isNullOrUndefined(statement.start) || isNullOrUndefined(statement.end)) {
+      continue;
+    }
+    const statementText = fakeJsContent.substring(statement.start, statement.end);
+    if (isImportDeclaration(statement) || isExportAllDeclaration(statement) || isReExportStatement(statement)) {
+      if (isImportDeclaration(statement)) {
+        resultParts.push(statementText.replace(/.(?:mjs|cjs|js)\b/g, ""));
+        continue;
+      }
+      resultParts.push(statementText);
+      continue;
+    }
+    if (statement.type === "ExpressionStatement") {
+      const namespaceDecl = handleNamespace(statement);
+      if (namespaceDecl) {
+        resultParts.push(namespaceDecl);
+        continue;
+      }
+    }
+    if (statement.type === "VariableDeclaration") {
+      for (const declaration of statement.declarations) {
+        if (declaration.init?.type === "ArrayExpression") {
+          const dtsContent = processTokenArray(declaration.init);
+          if (dtsContent) {
+            resultParts.push(dtsContent);
+          }
+        }
+      }
+    }
+  }
+  return resultParts.join(`
+`);
+}
+function jsifyImportExport(text) {
+  let result = text.replace(IMPORT_TYPE_RE, "import ").replace(EXPORT_TYPE_RE, "export ").replace(IMPORT_EXPORT_NAMES_RE, (_, keyword, names) => `${keyword} {${names.replace(TYPE_WORD_RE, "")}}`);
+  result = result.replace(IMPORT_EXPORT_WITH_DEFAULT_RE, (_, keyword, defaultPart = "", names = "") => {
+    const cleanedNames = names.replace(TYPE_WORD_RE, "");
+    return `${keyword}${defaultPart}{${cleanedNames}}`;
+  });
+  return result;
+}
+function tokenizeText(text, referencedNames) {
+  const tokens = [];
+  let match;
+  TOKENIZE_RE.lastIndex = 0;
+  while (true) {
+    match = TOKENIZE_RE.exec(text);
+    if (match === null)
+      break;
+    const token = match[0];
+    if (isLikelyVariableOrTypeName(token) || referencedNames.has(token)) {
+      tokens.push(token);
+    } else {
+      tokens.push(JSON.stringify(escapeNewlinesAndTabs(token)));
+    }
+  }
+  return tokens;
+}
+function processTokenArray(arrayLiteral) {
+  if (arrayLiteral.type !== "ArrayExpression") {
+    return null;
+  }
+  const tokens = [];
+  for (const element of arrayLiteral.elements) {
+    if (!element)
+      continue;
+    const processed = processTokenElement(element);
+    if (processed !== null) {
+      tokens.push(processed);
+    }
+  }
+  return tokens.join("");
+}
+function processTokenElement(element) {
+  if (element.type === "StringLiteral" && typeof element.value === "string") {
+    return unescapeNewlinesAndTabs(element.value);
+  }
+  if (element.type === "Identifier") {
+    return element.name;
+  }
+  if (element.type === "TemplateLiteral") {
+    const parts = [];
+    parts.push(unescapeNewlinesAndTabs(element.quasis[0]?.value?.raw || ""));
+    for (let i = 0;i < element.expressions.length; i++) {
+      const expr = element.expressions[i];
+      if (expr.type === "Identifier") {
+        parts.push(expr.name);
+      }
+      parts.push(unescapeNewlinesAndTabs(element.quasis[i + 1]?.value?.raw || ""));
+    }
+    return parts.join("");
+  }
+  return null;
+}
+function escapeNewlinesAndTabs(text) {
+  return text.replace(/\n/g, "__typeroll_intermediate_new__line__").replace(/\t/g, "__typeroll_intermediate__tab__");
+}
+function unescapeNewlinesAndTabs(text) {
+  return text.replace(/__typeroll_intermediate_new__line__/g, `
+`).replace(/__typeroll_intermediate__tab__/g, "\t");
+}
+function handleNamespace(stmt) {
+  const expr = stmt.expression;
+  if (!expr || expr.type !== "CallExpression" || expr.callee?.type !== "Identifier" || expr.arguments?.length !== 2 || expr.arguments[0].type !== "Identifier" || expr.arguments[1].type !== "ObjectExpression") {
+    return null;
+  }
+  const namespaceName = expr.arguments[0].name;
+  const properties = expr.arguments[1].properties.filter((prop) => prop.type === "ObjectProperty").map((prop) => {
+    if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.value.type === "ArrowFunctionExpression" && prop.value.body.type === "Identifier") {
+      const keyName = prop.key.name;
+      const returnName = prop.value.body.name;
+      return keyName === returnName ? keyName : `${returnName} as ${keyName}`;
+    }
+    return null;
+  }).filter(Boolean);
+  if (properties.length === 0) {
+    return null;
+  }
+  return `declare namespace ${namespaceName} {
+  export { ${properties.join(", ")} };
+}`;
+}
+
+// packages/dts/src/resolver.ts
+import { dirname } from "node:path";
+import process2 from "node:process";
+import { ResolverFactory } from "oxc-resolver";
+function createResolver({
+  tsconfig,
+  cwd = process2.cwd(),
+  resolveOption
+}) {
+  const resolver = new ResolverFactory({
+    mainFields: ["types", "typings", "module", "main"],
+    conditionNames: ["types", "typings", "import", "require"],
+    extensions: [".d.ts", ".d.mts", ".d.cts", ".ts", ".mts", ".cts"],
+    tsconfig: tsconfig ? { configFile: tsconfig, references: "auto" } : undefined
+  });
+  const resolutionCache = new Map;
+  return (importSource, importer) => {
+    if (importSource === "bun")
+      return null;
+    const cacheKey = `${importSource}:${importer || ""}`;
+    if (resolutionCache.has(cacheKey)) {
+      return resolutionCache.get(cacheKey) || null;
+    }
+    let shouldResolve = false;
+    if (resolveOption !== undefined) {
+      if (typeof resolveOption === "boolean") {
+        shouldResolve = resolveOption;
+      } else if (Array.isArray(resolveOption)) {
+        shouldResolve = resolveOption.some((resolver2) => {
+          if (typeof resolver2 === "string") {
+            return resolver2 === importSource;
+          }
+          return resolver2.test(importSource);
+        });
+      }
+    }
+    if (!shouldResolve) {
+      resolutionCache.set(cacheKey, null);
+      return null;
+    }
+    const directory = importer ? dirname(importer) : cwd;
+    const resolution = resolver.sync(directory, importSource);
+    if (!resolution.path) {
+      resolutionCache.set(cacheKey, null);
+      return null;
+    }
+    const resolved = resolution.path;
+    if (JS_RE.test(resolved)) {
+      const dts = returnPathIfExists(resolved.replace(JS_RE, ".d.ts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.mts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.cts"));
+      const result2 = isTypeScriptFile(dts) ? dts : null;
+      resolutionCache.set(cacheKey, result2);
+      return result2;
+    }
+    const result = isTypeScriptFile(resolved) ? resolved : null;
+    resolutionCache.set(cacheKey, result);
+    return result;
+  };
+}
+
+// packages/dts/src/generate.ts
+async function generateDts(entrypoints, options = {}) {
+  const { resolve, preferredTsConfigPath, naming } = options;
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+  const tsconfig = await loadTsConfig(cwd, preferredTsConfigPath);
+  const nonAbsoluteEntrypoints = entrypoints.filter((entrypoint) => !path.isAbsolute(entrypoint));
+  const resolvedEntrypoints = await getFilesFromGlobs(nonAbsoluteEntrypoints, cwd);
+  const absoluteEntrypoints = entrypoints.filter((entrypoint) => path.isAbsolute(entrypoint));
+  if (!filterTypescriptFiles([...resolvedEntrypoints, ...absoluteEntrypoints]).length) {
+    throw new TyperollError("One or more of the entrypoints you provided do not exist. Please check that each entrypoint points to a valid file.");
+  }
+  const collectedErrors = [];
+  const resolver = createResolver({
+    cwd,
+    resolveOption: resolve,
+    tsconfig: tsconfig.filepath
+  });
+  const fakeJsPlugin = {
+    name: "fake-js",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (!NODE_MODULES_RE.test(args.importer)) {
+          const resolved = resolveTsImportPath({
+            importer: args.importer,
+            path: args.path,
+            cwd,
+            tsconfig: tsconfig.config
+          });
+          if (resolved && isTypeScriptFile(resolved)) {
+            return { path: resolved };
+          }
+        }
+        const resolvedFromNodeModules = resolver(args.path, args.importer);
+        if (resolvedFromNodeModules) {
+          return { path: resolvedFromNodeModules };
+        }
+        return {
+          path: args.path,
+          external: true
+        };
+      });
+      build.onLoad({ filter: /\.(ts|tsx|d\.ts|d\.mts|d\.cts)$/ }, async (args) => {
+        const sourceText = await Bun.file(args.path).text();
+        const declarationResult = isolatedDeclaration(args.path, sourceText);
+        let fakeJsContent = "";
+        if (!collectedErrors.some((e) => e.file === args.path)) {
+          for (const error of declarationResult.errors) {
+            collectedErrors.push({
+              error,
+              file: args.path,
+              content: sourceText
+            });
+          }
+        }
+        if (declarationResult.code) {
+          fakeJsContent = await dtsToFakeJs(declarationResult.code);
+        } else {
+          fakeJsContent = EMPTY_EXPORT;
+        }
+        return {
+          loader: "js",
+          contents: fakeJsContent
+        };
+      });
+    }
+  };
+  const result = await Bun.build({
+    entrypoints: [
+      ...filterTypescriptFiles(resolvedEntrypoints).map((entry) => path.resolve(path.join(cwd, entry))),
+      ...filterTypescriptFiles(absoluteEntrypoints)
+    ],
+    format: "esm",
+    target: "node",
+    naming,
+    splitting: options.splitting,
+    plugins: [fakeJsPlugin],
+    packages: "external",
+    minify: options.minify,
+    throw: false
+  });
+  if (!result.success) {
+    throw new TyperollError(`DTS bundling failed: ${result.logs}`);
+  }
+  const outputs = result.outputs.filter((output) => output.kind === "chunk" || output.kind === "entry-point");
+  const bundledFiles = [];
+  for (const output of outputs) {
+    const bundledFakeJsContent = await output.text();
+    const dtsContent = await fakeJsToDts(bundledFakeJsContent);
+    const entrypoint = output.kind === "entry-point" ? entrypoints[bundledFiles.length] : undefined;
+    const chunkFileName = output.kind === "chunk" ? replaceExtension(path.basename(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))) : undefined;
+    const outputPath = cleanPath(replaceExtension(cleanPath(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))));
+    const treeshakedDts = isolatedDeclaration(`${generateRandomString()}.d.ts`, dtsContent);
+    if (!treeshakedDts.code.length && !treeshakedDts.errors.length) {
+      continue;
+    }
+    if (treeshakedDts.errors.length && !treeshakedDts.code) {
+      throw new TyperollError(`DTS treeshaking failed for ${entrypoint || outputPath}
+
+${JSON.stringify(treeshakedDts.errors, null, 2)}`);
+    }
+    bundledFiles.push({
+      kind: output.kind === "entry-point" ? "entry-point" : "chunk",
+      entrypoint,
+      chunkFileName,
+      outputPath,
+      dts: options.minify ? minifyDts(treeshakedDts.code) : treeshakedDts.code,
+      pathInfo: {
+        outputPathWithoutExtension: deleteExtension(outputPath),
+        ext: getExtension(outputPath)
+      }
+    });
+  }
+  return {
+    files: bundledFiles,
+    errors: collectedErrors
+  };
+}
+// packages/dts/src/isolated-decl-logger.ts
+import pc from "picocolors";
+var SEVERITY_CONFIG = {
+  dev: {
+    Error: { color: pc.yellow, prefix: "WARN" },
+    Warning: { color: pc.yellow, prefix: "WARN" },
+    Advice: { color: pc.blue, prefix: "ADVICE" },
+    default: { color: pc.blue, prefix: "WARN" }
+  },
+  prod: {
+    Error: { color: pc.red, prefix: "Error" },
+    Warning: { color: pc.yellow, prefix: "Warning" },
+    Advice: { color: pc.blue, prefix: "Advice" },
+    default: { color: pc.red, prefix: "Error" }
+  }
+};
+var ISOLATED_DECLARATION_ERRORS = {
+  TS9007: `Function requires an explicit return type, e.g., \`function foo(): ${pc.green("string")} { ... }\`.`,
+  TS9008: `Method requires an explicit return type, e.g., \`myMethod(): ${pc.green("number")} { ... }\`.`,
+  TS9009: "Ensure at least one accessor (getter/setter) has an explicit return type.",
+  TS9010: `Variable requires an explicit type annotation, e.g., \`let name: ${pc.green("string")} = "Bob";\`.`,
+  TS9011: `Function parameter requires an explicit type, e.g., \`(param: ${pc.green("number")}) => {}\`.`,
+  TS9012: `Class property requires an explicit type, e.g., \`class MyClass { id: ${pc.green("number")}; }\`.`,
+  TS9013: "Expression type cannot be inferred. Add a type annotation where this expression is assigned or used.",
+  TS9014: "Computed property names must be simple (e.g., string/number literals or basic identifiers).",
+  TS9015: "Either add an explicit type to the object or avoid spread.",
+  TS9016: "Either add an explicit type to the object or use full `key: value` syntax.",
+  TS9017: `For array type inference, use \`as const\` (e.g., \`[1, 2, 3] ${pc.green("as const")}\`).`,
+  TS9018: "Either add an explicit type to the array or avoid spread.",
+  TS9019: `Avoid direct export of destructured bindings. Instead, declare and then export, e.g., \`const { x } = obj; ${pc.green("export { x };")}\`.`,
+  TS9020: "Enum member initializers must be simple, constant values (like numbers or strings), not expressions or external references.",
+  TS9021: "The `extends` clause must refer to a direct class name, not an expression.",
+  TS9022: `Class expressions cannot infer types. Assign the class expression to an explicitly typed variable, e.g., \`const MyClass: ${pc.green("typeof OtherClass")} = class { ... };\`.`,
+  TS9023: `Properties assigned to functions must be explicitly declared on the function type/interface, e.g., \`interface MyFunc { (): void; ${pc.green("myProp: string;")} }\`.`,
+  TS9025: `Parameter can implicitly be \`undefined\`. Explicitly add \`| undefined\` to its type, e.g., \`param?: string\` becomes \`param: ${pc.green("string | undefined")}\`.`,
+  TS9037: `Default export requires an explicit type, e.g., \`const MyValue: ${pc.green("number")} = 42; export default MyValue;\`.`,
+  TS9038: "Computed property names in class/object literals must be simple (string/number literals or plain identifiers), not complex expressions.",
+  TS9039: "A type references a private class member (`{name}`). Private members cannot be part of publicly exposed types."
+};
+function logIsolatedDeclarationErrors(errors) {
+  if (!errors.length)
+    return;
+  const hasErrors = errors.some(({ error }) => error.severity === "Error");
+  console.log();
+  errors.forEach(logSingle);
+  if (hasErrors) {
+    if (!isDev())
+      process.exit(1);
+  }
+}
+function logSingle({ error, file, content }) {
+  const label = error.labels?.[0];
+  const errorCode = extractErrorCode(error.message);
+  const errorMessage = ISOLATED_DECLARATION_ERRORS[errorCode];
+  if (!errorMessage)
+    return;
+  const position = label ? calculatePosition(content, label.start) : "";
+  const shortPath = getShortFilePath(file);
+  const { color, prefix } = getSeverityFormatting(error.severity);
+  const formattedMessage = `${color(prefix)} ${shortPath}${position}: ${errorCode} ${errorMessage}`;
+  const codeFrame = label ? generateOxcCodeFrame(content, label.start, label.end) : error.codeframe || "";
+  const helpMessage = error.helpMessage ? `
+${pc.cyan("Help:")} ${error.helpMessage}` : "";
+  console.log(`${formattedMessage}${helpMessage}
+
+${pc.gray(codeFrame)}
+`);
+}
+function extractErrorCode(message) {
+  return message.split(":")[0];
+}
+function getSeverityFormatting(severity) {
+  const config = SEVERITY_CONFIG[isDev() ? "dev" : "prod"];
+  return config[severity] || config.default;
+}
+function calculatePosition(sourceText, labelStart) {
+  if (labelStart === undefined)
+    return "";
+  const lines = sourceText.slice(0, labelStart).split(`
+`);
+  const lineNumber = lines.length;
+  const columnStart = lines[lines.length - 1].length + 1;
+  return ` (${lineNumber}:${columnStart})`;
+}
+function generateOxcCodeFrame(sourceText, start, end) {
+  const lines = sourceText.split(`
+`);
+  const errorLine = sourceText.slice(0, start).split(`
+`).length;
+  const lineContent = lines[errorLine - 1];
+  const lastNewlineIndex = sourceText.slice(0, start).lastIndexOf(`
+`);
+  const startCol = start - lastNewlineIndex - 1;
+  const endCol = end ? Math.min(end - lastNewlineIndex - 1, lineContent.length) : startCol + 1;
+  const underlineLength = Math.max(1, endCol - startCol);
+  const arrowLine = " ".repeat(startCol) + pc.dim(pc.blue("⎯".repeat(underlineLength)));
+  return `${lineContent}
+${arrowLine}`;
+}
+export {
+  logIsolatedDeclarationErrors,
+  generateDts
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@bunup/dts",
+	"description": "An extremely fast TypeScript declaration file generator and bundler that outputs to a single file.",
+	"version": "0.11.19",
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/index.d.ts",
+				"default": "./dist/index.js"
+			}
+		}
+	},
+	"dependencies": {
+		"@babel/parser": "^7.28.0",
+		"coffi": "^0.1.31",
+		"oxc-minify": "^0.77.2",
+		"oxc-resolver": "^8.0.0",
+		"oxc-transform": "^0.67.0",
+		"picocolors": "^1.1.1",
+		"std-env": "^3.9.0",
+		"ts-import-resolver": "^0.1.23"
+	},
+	"license": "MIT",
+	"author": "Arshad Yaseen <m@arshadyaseen.com> (https://arshadyaseen.com)",
+	"maintainers": [
+		{
+			"name": "Arshad Yaseen",
+			"email": "m@arshadyaseen.com",
+			"url": "https://arshadyaseen.com"
+		}
+	],
+	"keywords": [
+		"typescript",
+		"dts",
+		"declaration",
+		"declaration generation",
+		"bun",
+		"bun dts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/bunup/bunup.git"
+	},
+	"funding": "https://github.com/sponsors/arshad-yaseen",
+	"homepage": "https://bunup.dev",
+	"peerDependencies": {
+		"typescript": ">=4.5.0"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@babel/types": "^7.28.2"
+	}
+}