@savvy-web/rslib-builder 0.2.2 → 0.4.0

package/index.js

@@ -3,13 +3,14 @@ import * as __rspack_external_node_path_c5b9b54f from "node:path";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { constants, existsSync, writeFileSync } from "node:fs";
 import { defineConfig } from "@rslib/core";
-import { access, copyFile, mkdir, readFile as promises_readFile, readdir, rm, stat as promises_stat, unlink, writeFile } from "node:fs/promises";
-import { getWorkspaceRoot } from "workspace-tools";
+import { access, copyFile, mkdir, readFile, readdir, rm, stat, unlink as promises_unlink, writeFile } from "node:fs/promises";
 import { logger as core_logger } from "@rsbuild/core";
 import picocolors from "picocolors";
+import { getWorkspaceRoot } from "workspace-tools";
 import { spawn } from "node:child_process";
 import { StandardTags, Standardization, TSDocTagSyntaxKind } from "@microsoft/tsdoc";
-import { createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
+import deep_equal from "deep-equal";
+import typescript, { createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
 import { createRequire } from "node:module";
 import { inspect } from "node:util";
 import sort_package_json from "sort-package-json";
@@ -20,38 +21,6 @@ __webpack_require__.add({
         module.exports = __rspack_external_node_path_c5b9b54f;
     }
 });
-const external_node_path_ = __webpack_require__("node:path");
-async function fileExistAsync(assetName) {
-    const assetPath = (0, external_node_path_.join)(process.cwd(), assetName);
-    const assetExists = !!await promises_stat(assetPath).catch(()=>false);
-    return {
-        assetName,
-        assetPath,
-        assetExists
-    };
-}
-async function packageJsonVersion() {
-    const { assetExists, assetPath } = await fileExistAsync("package.json");
-    if (!assetExists) throw new Error("package.json not found in project root");
-    try {
-        const json = await promises_readFile(assetPath, "utf-8");
-        const { version } = JSON.parse(json);
-        return version;
-    } catch  {
-        throw new Error("Failed to read version from package.json");
-    }
-}
-function getApiExtractorPath() {
-    const cwd = process.cwd();
-    const localApiExtractor = (0, external_node_path_.join)(cwd, "node_modules", "@microsoft", "api-extractor");
-    if (existsSync(localApiExtractor)) return localApiExtractor;
-    const workspaceRoot = getWorkspaceRoot(cwd);
-    if (workspaceRoot) {
-        const workspaceApiExtractor = (0, external_node_path_.join)(workspaceRoot, "node_modules", "@microsoft", "api-extractor");
-        if (existsSync(workspaceApiExtractor)) return workspaceApiExtractor;
-    }
-    throw new Error("API Extractor bundling requires @microsoft/api-extractor to be installed.\nInstall it with: pnpm add -D @microsoft/api-extractor");
-}
 const { cyan: cyan, dim: dim, bold: bold } = picocolors;
 function formatTime(ms) {
     if (ms < 1000) return `${ms}ms`;
@@ -182,6 +151,38 @@ function extractEntriesFromPackageJson(packageJson, options) {
     const extractor = new EntryExtractor(options);
     return extractor.extract(packageJson);
 }
+const external_node_path_ = __webpack_require__("node:path");
+async function fileExistAsync(assetName) {
+    const assetPath = (0, external_node_path_.join)(process.cwd(), assetName);
+    const assetExists = !!await stat(assetPath).catch(()=>false);
+    return {
+        assetName,
+        assetPath,
+        assetExists
+    };
+}
+async function packageJsonVersion() {
+    const { assetExists, assetPath } = await fileExistAsync("package.json");
+    if (!assetExists) throw new Error("package.json not found in project root");
+    try {
+        const json = await readFile(assetPath, "utf-8");
+        const { version } = JSON.parse(json);
+        return version;
+    } catch  {
+        throw new Error("Failed to read version from package.json");
+    }
+}
+function getApiExtractorPath() {
+    const cwd = process.cwd();
+    const localApiExtractor = (0, external_node_path_.join)(cwd, "node_modules", "@microsoft", "api-extractor");
+    if (existsSync(localApiExtractor)) return localApiExtractor;
+    const workspaceRoot = getWorkspaceRoot(cwd);
+    if (workspaceRoot) {
+        const workspaceApiExtractor = (0, external_node_path_.join)(workspaceRoot, "node_modules", "@microsoft", "api-extractor");
+        if (existsSync(workspaceApiExtractor)) return workspaceApiExtractor;
+    }
+    throw new Error("API Extractor bundling requires @microsoft/api-extractor to be installed.\nInstall it with: pnpm add -D @microsoft/api-extractor");
+}
 const AutoEntryPlugin = (options)=>{
     const buildStateMap = new WeakMap();
     return {
@@ -212,7 +213,7 @@ const AutoEntryPlugin = (options)=>{
                     throw new Error("package.json not found in project root");
                 }
                 try {
-                    const packageJsonContent = await promises_readFile(assetPath, "utf-8");
+                    const packageJsonContent = await readFile(assetPath, "utf-8");
                     const packageJson = JSON.parse(packageJsonContent);
                     const { entries } = extractEntriesFromPackageJson(packageJson, {
                         exportsAsIndexes: options?.exportsAsIndexes
@@ -265,16 +266,11 @@ const AutoEntryPlugin = (options)=>{
     };
 };
 var lib_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig.json","compilerOptions":{"allowSyntheticDefaultImports":true,"composite":true,"declaration":true,"declarationDir":"${configDir}/dist","declarationMap":false,"emitDeclarationOnly":false,"esModuleInterop":true,"explainFiles":false,"forceConsistentCasingInFileNames":true,"incremental":true,"isolatedDeclarations":true,"isolatedModules":true,"jsx":"preserve","lib":["esnext"],"module":"nodenext","moduleResolution":"nodenext","outDir":"${configDir}/dist","resolveJsonModule":true,"rootDir":"${configDir}","skipLibCheck":true,"sourceMap":false,"strict":true,"strictNullChecks":true,"target":"es2023","tsBuildInfoFile":"${configDir}/dist/.tsbuildinfo.lib","typeRoots":["${configDir}/node_modules/@types","${configDir}/types"],"verbatimModuleSyntax":true},"exclude":["${configDir}/node_modules","${configDir}/dist/**/*"],"include":["${configDir}/types/*.ts","${configDir}/package.json","${configDir}/*.ts","${configDir}/*.cts","${configDir}/*.mts","${configDir}/src/**/*.ts","${configDir}/src/**/*.tsx","${configDir}/src/**/*.cts","${configDir}/src/**/*.mts","${configDir}/lib/**/*.ts","${configDir}/lib/**/*.tsx","${configDir}/lib/**/*.cts","${configDir}/lib/**/*.mts","${configDir}/public/**/*.json"]}');
-var root_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig","compilerOptions":{"composite":true,"declaration":true,"module":"node20","outDir":"dist","resolveJsonModule":true,"strict":true,"strictNullChecks":true,"target":"es2023"}}');
 const requireCJS = createRequire(import.meta.url);
 const jsonImports = new Map([
     [
         (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/ecma/lib.json"),
         lib_namespaceObject
-    ],
-    [
-        (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/root.json"),
-        root_namespaceObject
     ]
 ]);
 function transformStringsDeep(value, transform) {
@@ -306,26 +302,6 @@ class TSConfigFile {
     constructor(description, pathname){
         this.pathname = pathname;
         this.description = description;
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            get: ()=>`./${(0, external_node_path_.relative)(process.cwd(), this.pathname)}`
-        });
-        Object.defineProperty(this, "config", {
-            enumerable: true,
-            get: ()=>{
-                const imported = jsonImports.get(this.pathname);
-                if (!imported) throw new Error(`Config file not found in imports: ${this.pathname}`);
-                return imported;
-            }
-        });
-        Object.defineProperty(this, "bundled", {
-            enumerable: true,
-            get: ()=>{
-                const imported = jsonImports.get(this.pathname);
-                if (!imported) throw new Error(`Config file not found in imports: ${this.pathname}`);
-                return transformStringsDeep(imported, (str)=>str.replace("${configDir}", "../../../../../.."));
-            }
-        });
         Object.defineProperty(this, inspect.custom, {
             value: (_depth, options)=>inspect({
                     description: this.description,
@@ -385,10 +361,8 @@ class LibraryTSConfigFile extends TSConfigFile {
         return tmpFile.name;
     }
 }
-const Root = new TSConfigFile("Root configuration for workspace setup", (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/root.json"));
 const NodeEcmaLib = new LibraryTSConfigFile("ECMAScript library build configuration", (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/ecma/lib.json"));
 const TSConfigs = {
-    root: Root,
     node: {
         ecma: {
             lib: NodeEcmaLib
@@ -473,7 +447,14 @@ class TsDocConfigBuilder {
         if (tagDefinitions.length > 0) tsdocConfig.tagDefinitions = tagDefinitions;
         if (Object.keys(supportForTags).length > 0) tsdocConfig.supportForTags = supportForTags;
         const configPath = (0, external_node_path_.join)(outputDir, "tsdoc.json");
-        await writeFile(configPath, JSON.stringify(tsdocConfig, null, 2));
+        if (existsSync(configPath)) try {
+            const existingContent = await readFile(configPath, "utf-8");
+            const existingConfig = JSON.parse(existingContent);
+            if (deep_equal(existingConfig, tsdocConfig, {
+                strict: true
+            })) return configPath;
+        } catch  {}
+        await writeFile(configPath, `${JSON.stringify(tsdocConfig, null, "\t")}\n`);
         return configPath;
     }
     static syntaxKindToString(kind) {
@@ -647,7 +628,7 @@ async function bundleDtsFiles(options) {
         if (generateApiModel && tempApiModelPath) apiModelPath = tempApiModelPath;
         if (generateTsdocMetadata && tempTsdocMetadataPath) tsdocMetadataPath = tempTsdocMetadataPath;
         if (banner || footer) {
-            let content = await promises_readFile(tempBundledPath, "utf-8");
+            let content = await readFile(tempBundledPath, "utf-8");
             if (banner) content = `${banner}\n${content}`;
             if (footer) content = `${content}\n${footer}`;
             await writeFile(tempBundledPath, content, "utf-8");
@@ -657,7 +638,7 @@ async function bundleDtsFiles(options) {
     let persistedTsdocConfigPath;
     if (tsdocConfigPath) if (shouldPersist) persistedTsdocConfigPath = tsdocConfigPath;
     else try {
-        await unlink(tsdocConfigPath);
+        await promises_unlink(tsdocConfigPath);
     } catch  {}
     return {
         bundledFiles,
@@ -819,7 +800,7 @@ function runTsgo(options) {
                                 });
                                 await copyFile(file.path, newPath);
                                 log.global.info(`Renamed ${file.relativePath} -> ${originalDtsPath} (from temp api-extractor)`);
-                                await unlink(file.path);
+                                await promises_unlink(file.path);
                             }
                         }
                         allDtsFiles.length = 0;
@@ -838,7 +819,7 @@ function runTsgo(options) {
                             packageJson = exposedPackageJson;
                         } else {
                             const packageJsonPath = (0, external_node_path_.join)(cwd, "package.json");
-                            const packageJsonContent = await promises_readFile(packageJsonPath, "utf-8");
+                            const packageJsonContent = await readFile(packageJsonPath, "utf-8");
                             packageJson = JSON.parse(packageJsonContent);
                         }
                         const entryPoints = new Map();
@@ -884,7 +865,7 @@ function runTsgo(options) {
                             let emittedCount = 0;
                             for (const [entryName, tempBundledPath] of bundledFiles){
                                 const bundledFileName = `${entryName}.d.ts`;
-                                let content = await promises_readFile(tempBundledPath, "utf-8");
+                                let content = await readFile(tempBundledPath, "utf-8");
                                 content = stripSourceMapComment(content);
                                 const source = new context.sources.OriginalSource(content, bundledFileName);
                                 context.compilation.emitAsset(bundledFileName, source);
@@ -895,7 +876,7 @@ function runTsgo(options) {
                             if (apiModelPath) {
                                 const defaultApiModelFilename = packageJson.name ? `${getUnscopedPackageName(packageJson.name)}.api.json` : "api.json";
                                 const apiModelFilename = "object" == typeof options.apiModel && options.apiModel.filename ? options.apiModel.filename : defaultApiModelFilename;
-                                const apiModelContent = await promises_readFile(apiModelPath, "utf-8");
+                                const apiModelContent = await readFile(apiModelPath, "utf-8");
                                 const apiModelSource = new context.sources.OriginalSource(apiModelContent, apiModelFilename);
                                 context.compilation.emitAsset(apiModelFilename, apiModelSource);
                                 if (filesArray) filesArray.add(`!${apiModelFilename}`);
@@ -918,14 +899,14 @@ function runTsgo(options) {
                             if (tsdocMetadataPath) {
                                 const tsdocMetadataOption = "object" == typeof options.apiModel ? options.apiModel.tsdocMetadata : void 0;
                                 const tsdocMetadataFilename = "object" == typeof tsdocMetadataOption && tsdocMetadataOption.filename ? tsdocMetadataOption.filename : "tsdoc-metadata.json";
-                                const tsdocMetadataContent = await promises_readFile(tsdocMetadataPath, "utf-8");
+                                const tsdocMetadataContent = await readFile(tsdocMetadataPath, "utf-8");
                                 const tsdocMetadataSource = new context.sources.OriginalSource(tsdocMetadataContent, tsdocMetadataFilename);
                                 context.compilation.emitAsset(tsdocMetadataFilename, tsdocMetadataSource);
                                 if (filesArray) filesArray.add(tsdocMetadataFilename);
                                 core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted TSDoc metadata: ${tsdocMetadataFilename}`);
                             }
                             if (tsdocConfigPath) {
-                                const tsdocConfigContent = await promises_readFile(tsdocConfigPath, "utf-8");
+                                const tsdocConfigContent = await readFile(tsdocConfigPath, "utf-8");
                                 const tsdocConfigSource = new context.sources.OriginalSource(tsdocConfigContent, "tsdoc.json");
                                 context.compilation.emitAsset("tsdoc.json", tsdocConfigSource);
                                 if (filesArray) filesArray.add("!tsdoc.json");
@@ -953,7 +934,7 @@ function runTsgo(options) {
                         let emittedCount = 0;
                         for (const file of dtsFiles){
                             if (file.relativePath.endsWith(".d.ts.map")) continue;
-                            let content = await promises_readFile(file.path, "utf-8");
+                            let content = await readFile(file.path, "utf-8");
                             let outputPath = file.relativePath;
                             if (outputPath.startsWith("src/")) outputPath = outputPath.slice(4);
                             if (".d.ts" !== dtsExtension && outputPath.endsWith(".d.ts")) outputPath = outputPath.replace(/\.d\.ts$/, dtsExtension);
@@ -1022,7 +1003,7 @@ function runTsgo(options) {
                         recursive: true
                     });
                     for (const file of filesToCopy){
-                        const content = await promises_readFile(file.src, "utf-8");
+                        const content = await readFile(file.src, "utf-8");
                         await writeFile(file.dest, content, "utf-8");
                     }
                     const fileNames = filesToCopy.map((f)=>f.name).join(", ");
@@ -1055,7 +1036,7 @@ class TextAsset {
         if (asset) return new TextAsset(context, fileName);
         try {
             const filePath = (0, external_node_path_.join)(process.cwd(), fileName);
-            const content = await promises_readFile(filePath, "utf-8");
+            const content = await readFile(filePath, "utf-8");
             const source = new context.sources.RawSource(content);
             context.compilation.emitAsset(fileName, source);
             asset = source;
@@ -1085,7 +1066,7 @@ class JsonAsset extends TextAsset {
         if (asset) return new JsonAsset(context, fileName);
         try {
             const filePath = (0, external_node_path_.join)(process.cwd(), fileName);
-            const content = await promises_readFile(filePath, "utf-8");
+            const content = await readFile(filePath, "utf-8");
             const source = new context.sources.RawSource(content);
             context.compilation.emitAsset(fileName, source);
             asset = source;
@@ -1166,10 +1147,10 @@ class PnpmCatalog {
                 if (!this.cachedWorkspaceRoot) throw new Error("Could not find workspace root - ensure you're in a workspace");
             }
             const workspaceFile = (0, external_node_path_.resolve)(this.cachedWorkspaceRoot, "pnpm-workspace.yaml");
-            const stats = await promises_stat(workspaceFile);
+            const stats = await stat(workspaceFile);
             const currentMtime = stats.mtime.getTime();
             if (null !== this.catalogCache && this.catalogCacheMtime === currentMtime) return this.catalogCache;
-            const content = await promises_readFile(workspaceFile, "utf-8");
+            const content = await readFile(workspaceFile, "utf-8");
             const workspace = parse(content);
             this.catalogCache = workspace.catalog ?? {};
             this.catalogCacheMtime = currentMtime;
@@ -1300,135 +1281,6 @@ function getDefaultPnpmCatalog() {
     if (!defaultInstance) defaultInstance = new PnpmCatalog();
     return defaultInstance;
 }
-class PackageJsonTransformer {
-    options;
-    pnpmCatalog;
-    constructor(options = {}){
-        this.options = {
-            processTSExports: options.processTSExports ?? true,
-            collapseIndex: options.collapseIndex ?? false,
-            entrypoints: options.entrypoints ?? new Map(),
-            exportToOutputMap: options.exportToOutputMap ?? new Map()
-        };
-        this.pnpmCatalog = new PnpmCatalog();
-    }
-    transformExportPath(path) {
-        let transformedPath = path;
-        if (transformedPath.startsWith("./src/")) transformedPath = `./${transformedPath.slice(6)}`;
-        if (transformedPath.startsWith("./exports/")) transformedPath = `./${transformedPath.slice(10)}`;
-        if (transformedPath.startsWith("./public/")) transformedPath = `./${transformedPath.slice(9)}`;
-        if (this.options.processTSExports) {
-            const { collapseIndex } = this.options;
-            if (collapseIndex && transformedPath.endsWith("/index.ts") && "./index.ts" !== transformedPath) transformedPath = `${transformedPath.slice(0, -9)}.js`;
-            else if (collapseIndex && transformedPath.endsWith("/index.tsx") && "./index.tsx" !== transformedPath) transformedPath = `${transformedPath.slice(0, -10)}.js`;
-            else if (transformedPath.endsWith(".tsx")) transformedPath = `${transformedPath.slice(0, -4)}.js`;
-            else if (transformedPath.endsWith(".ts") && !transformedPath.endsWith(".d.ts")) transformedPath = `${transformedPath.slice(0, -3)}.js`;
-        }
-        return transformedPath;
-    }
-    createTypePath(jsPath) {
-        const { collapseIndex } = this.options;
-        if (collapseIndex && jsPath.endsWith("/index.js") && "./index.js" !== jsPath) return `${jsPath.slice(0, -9)}.d.ts`;
-        if (jsPath.endsWith(".js")) return `${jsPath.slice(0, -3)}.d.ts`;
-        return `${jsPath}.d.ts`;
-    }
-    transformExports(exports, exportKey) {
-        if ("string" == typeof exports) return this.transformStringExport(exports, exportKey);
-        if (Array.isArray(exports)) return exports.map((item)=>{
-            const transformed = this.transformExports(item, exportKey);
-            return transformed ?? item;
-        });
-        if (exports && "object" == typeof exports) return this.transformObjectExports(exports, exportKey);
-        return exports;
-    }
-    transformBin(bin) {
-        if ("string" == typeof bin) {
-            if (bin.endsWith(".ts") || bin.endsWith(".tsx")) return "./bin/cli.js";
-            return bin;
-        }
-        if (bin && "object" == typeof bin) {
-            const transformed = {};
-            for (const [command, path] of Object.entries(bin))if (void 0 !== path) if (path.endsWith(".ts") || path.endsWith(".tsx")) transformed[command] = `./bin/${command}.js`;
-            else transformed[command] = path;
-            return transformed;
-        }
-        return bin;
-    }
-    async transform(packageJson, context = {}) {
-        const { isProduction = false, customTransform } = context;
-        let result;
-        if (isProduction) {
-            const pnpmTransformed = await this.applyPnpmTransformations(packageJson);
-            result = this.applyRslibTransformations(pnpmTransformed, packageJson);
-        } else result = this.applyRslibTransformations(packageJson, packageJson);
-        if (customTransform) result = customTransform(result);
-        return result;
-    }
-    async applyPnpmTransformations(packageJson) {
-        return this.pnpmCatalog.resolvePackageJson(packageJson);
-    }
-    applyRslibTransformations(packageJson, originalPackageJson) {
-        const { publishConfig, scripts, ...rest } = packageJson;
-        let isPrivate = true;
-        if (originalPackageJson.publishConfig?.access === "public") isPrivate = false;
-        const processedManifest = {
-            ...rest,
-            private: isPrivate
-        };
-        if (processedManifest.exports) processedManifest.exports = this.transformExports(processedManifest.exports);
-        if (processedManifest.bin) processedManifest.bin = this.transformBin(processedManifest.bin);
-        if (originalPackageJson.typesVersions) {
-            const transformedTypesVersions = {};
-            for (const [version, paths] of Object.entries(originalPackageJson.typesVersions)){
-                const transformedPaths = {};
-                for (const [key, value] of Object.entries(paths))transformedPaths[key] = value.map((path)=>this.transformExportPath(path));
-                transformedTypesVersions[version] = transformedPaths;
-            }
-            processedManifest.typesVersions = transformedTypesVersions;
-        }
-        if (originalPackageJson.files) processedManifest.files = originalPackageJson.files.map((file)=>{
-            let transformedFile = file.startsWith("./") ? file.slice(2) : file;
-            if (transformedFile.startsWith("public/")) transformedFile = transformedFile.slice(7);
-            return transformedFile;
-        });
-        return sort_package_json(processedManifest);
-    }
-    transformStringExport(exportString, exportKey) {
-        const { entrypoints, exportToOutputMap, processTSExports } = this.options;
-        let transformedPath;
-        if (exportToOutputMap.size > 0 && exportKey && exportToOutputMap.has(exportKey)) {
-            const mappedPath = exportToOutputMap.get(exportKey);
-            if (!mappedPath) throw new Error(`Export key "${exportKey}" has no mapped path`);
-            transformedPath = mappedPath;
-        } else if (entrypoints.size > 0 && exportKey) {
-            const keyWithoutPrefix = exportKey.startsWith("./") ? exportKey.slice(2) : exportKey;
-            transformedPath = entrypoints.has(exportKey) ? entrypoints.get(exportKey) ?? exportString : entrypoints.has(keyWithoutPrefix) ? entrypoints.get(keyWithoutPrefix) ?? exportString : this.transformExportPath(exportString);
-        } else transformedPath = this.transformExportPath(exportString);
-        if (processTSExports && (exportString.endsWith(".ts") || exportString.endsWith(".tsx")) && !exportString.endsWith(".d.ts")) return {
-            types: this.createTypePath(transformedPath),
-            import: transformedPath
-        };
-        return transformedPath;
-    }
-    transformObjectExports(exportsObject, exportKey) {
-        const transformed = {};
-        const isConditions = this.isConditionsObject(exportsObject);
-        for (const [key, value] of Object.entries(exportsObject))transformed[key] = this.transformExportEntry(key, value, isConditions, exportKey);
-        return transformed;
-    }
-    isConditionsObject(exports) {
-        return Object.keys(exports).some((key)=>"import" === key || "require" === key || "types" === key || "default" === key);
-    }
-    transformExportEntry(key, value, isConditions, exportKey) {
-        if (isConditions && ("import" === key || "require" === key || "types" === key || "default" === key)) {
-            if ("string" == typeof value) return this.transformExportPath(value);
-            if (null != value) return this.transformExports(value, exportKey);
-            return value;
-        }
-        if (null != value) return this.transformExports(value, key);
-        return value;
-    }
-}
 function transformExportPath(path, processTSExports = true, collapseIndex = false) {
     let transformedPath = path;
     if (transformedPath.startsWith("./src/")) transformedPath = `./${transformedPath.slice(6)}`;
@@ -1596,6 +1448,430 @@ const PackageJsonTransformPlugin = (options = {})=>{
         }
     };
 };
+class ImportGraph {
+    options;
+    sys;
+    program = null;
+    compilerOptions = null;
+    moduleResolutionCache = null;
+    constructor(options){
+        this.options = options;
+        this.sys = options.sys ?? typescript.sys;
+    }
+    traceFromEntries(entryPaths) {
+        const errors = [];
+        const visited = new Set();
+        const entries = [];
+        const initResult = this.initializeProgram();
+        if (!initResult.success) return {
+            files: [],
+            entries: [],
+            errors: [
+                initResult.error
+            ]
+        };
+        for (const entryPath of entryPaths){
+            const absolutePath = this.resolveEntryPath(entryPath);
+            if (!this.sys.fileExists(absolutePath)) {
+                errors.push({
+                    type: "entry_not_found",
+                    message: `Entry file not found: ${entryPath}`,
+                    path: absolutePath
+                });
+                continue;
+            }
+            entries.push(absolutePath);
+            this.traceImports(absolutePath, visited, errors);
+        }
+        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
+        return {
+            files: files.sort(),
+            entries,
+            errors
+        };
+    }
+    traceFromPackageExports(packageJsonPath) {
+        const absolutePath = this.resolveEntryPath(packageJsonPath);
+        let packageJson;
+        try {
+            const content = this.sys.readFile(absolutePath);
+            if (!content) return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_not_found",
+                        message: `Failed to read package.json: File not found at ${absolutePath}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+            packageJson = JSON.parse(content);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_parse_error",
+                        message: `Failed to parse package.json: ${message}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+        }
+        const extractor = new EntryExtractor();
+        const { entries } = extractor.extract(packageJson);
+        const packageDir = (0, external_node_path_.dirname)(absolutePath);
+        const entryPaths = Object.values(entries).map((p)=>(0, external_node_path_.resolve)(packageDir, p));
+        return this.traceFromEntries(entryPaths);
+    }
+    initializeProgram() {
+        if (this.program) return {
+            success: true
+        };
+        const configPath = this.findTsConfig();
+        if (!configPath) return {
+            success: false,
+            error: {
+                type: "tsconfig_not_found",
+                message: `No tsconfig.json found in ${this.options.rootDir}`,
+                path: this.options.rootDir
+            }
+        };
+        const configFile = typescript.readConfigFile(configPath, (path)=>this.sys.readFile(path));
+        if (configFile.error) {
+            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_read_error",
+                    message: `Failed to read tsconfig.json: ${message}`,
+                    path: configPath
+                }
+            };
+        }
+        const parsed = typescript.parseJsonConfigFileContent(configFile.config, this.sys, (0, external_node_path_.dirname)(configPath));
+        if (parsed.errors.length > 0) {
+            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_parse_error",
+                    message: `Failed to parse tsconfig.json: ${messages}`,
+                    path: configPath
+                }
+            };
+        }
+        this.compilerOptions = parsed.options;
+        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
+        const host = typescript.createCompilerHost(this.compilerOptions, true);
+        host.getCurrentDirectory = ()=>this.options.rootDir;
+        this.program = typescript.createProgram([], this.compilerOptions, host);
+        return {
+            success: true
+        };
+    }
+    findTsConfig() {
+        if (this.options.tsconfigPath) {
+            const customPath = (0, external_node_path_.isAbsolute)(this.options.tsconfigPath) ? this.options.tsconfigPath : (0, external_node_path_.resolve)(this.options.rootDir, this.options.tsconfigPath);
+            if (this.sys.fileExists(customPath)) return customPath;
+            return null;
+        }
+        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>this.sys.fileExists(path));
+        return configPath ?? null;
+    }
+    resolveEntryPath(entryPath) {
+        if ((0, external_node_path_.isAbsolute)(entryPath)) return (0, external_node_path_.normalize)(entryPath);
+        return (0, external_node_path_.normalize)((0, external_node_path_.resolve)(this.options.rootDir, entryPath));
+    }
+    traceImports(filePath, visited, errors) {
+        const normalizedPath = (0, external_node_path_.normalize)(filePath);
+        if (visited.has(normalizedPath)) return;
+        if (this.isExternalModule(normalizedPath)) return;
+        visited.add(normalizedPath);
+        const content = this.sys.readFile(normalizedPath);
+        if (!content) return void errors.push({
+            type: "file_read_error",
+            message: `Failed to read file: ${normalizedPath}`,
+            path: normalizedPath
+        });
+        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
+        const imports = this.extractImports(sourceFile);
+        for (const importPath of imports){
+            const resolved = this.resolveImport(importPath, normalizedPath);
+            if (resolved) this.traceImports(resolved, visited, errors);
+        }
+    }
+    extractImports(sourceFile) {
+        const imports = [];
+        const visit = (node)=>{
+            if (typescript.isImportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isExportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isCallExpression(node)) {
+                const expression = node.expression;
+                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                    const arg = node.arguments[0];
+                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
+                }
+            }
+            typescript.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return imports;
+    }
+    resolveImport(specifier, fromFile) {
+        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
+        }
+        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
+        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, this.sys, this.moduleResolutionCache);
+        if (resolved.resolvedModule) {
+            const resolvedPath = resolved.resolvedModule.resolvedFileName;
+            if (resolved.resolvedModule.isExternalLibraryImport) return null;
+            if (resolvedPath.endsWith(".d.ts")) {
+                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
+                if (this.sys.fileExists(sourcePath)) return sourcePath;
+                return null;
+            }
+            return resolvedPath;
+        }
+        return null;
+    }
+    isExternalModule(filePath) {
+        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+    }
+    isSourceFile(filePath) {
+        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) return false;
+        if (filePath.endsWith(".d.ts")) return false;
+        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
+        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
+        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
+        const excludePatterns = this.options.excludePatterns ?? [];
+        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
+        return true;
+    }
+    static fromEntries(entryPaths, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromEntries(entryPaths);
+    }
+    static fromPackageExports(packageJsonPath, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromPackageExports(packageJsonPath);
+    }
+}
+function formatLintResults(results, cwd) {
+    if (0 === results.messages.length) return "";
+    const lines = [];
+    const messagesByFile = new Map();
+    for (const msg of results.messages){
+        const existing = messagesByFile.get(msg.filePath) ?? [];
+        existing.push(msg);
+        messagesByFile.set(msg.filePath, existing);
+    }
+    for (const [filePath, messages] of messagesByFile){
+        lines.push(picocolors.underline(picocolors.cyan((0, external_node_path_.relative)(cwd, filePath))));
+        for (const msg of messages){
+            const location = picocolors.dim(`${msg.line}:${msg.column}`);
+            const severityColor = 2 === msg.severity ? picocolors.red : picocolors.yellow;
+            const severityLabel = 2 === msg.severity ? "error" : "warning";
+            const rule = msg.ruleId ? picocolors.dim(`(${msg.ruleId})`) : "";
+            lines.push(`  ${location}  ${severityColor(severityLabel)}  ${msg.message} ${rule}`);
+        }
+        lines.push("");
+    }
+    const errorText = 1 === results.errorCount ? "error" : "errors";
+    const warningText = 1 === results.warningCount ? "warning" : "warnings";
+    const summary = results.errorCount > 0 ? picocolors.red(`${results.errorCount} ${errorText}`) : picocolors.yellow(`${results.warningCount} ${warningText}`);
+    lines.push(summary);
+    return lines.join("\n");
+}
+function discoverFilesToLint(options, cwd) {
+    if (options.include && options.include.length > 0) return {
+        files: options.include,
+        errors: [],
+        isGlobPattern: true
+    };
+    const graph = new ImportGraph({
+        rootDir: cwd
+    });
+    const packageJsonPath = (0, external_node_path_.join)(cwd, "package.json");
+    const result = graph.traceFromPackageExports(packageJsonPath);
+    return {
+        files: result.files,
+        errors: result.errors,
+        isGlobPattern: false
+    };
+}
+async function runTsDocLint(options, cwd) {
+    const tsdocOptions = options.tsdoc ?? {};
+    const persistConfig = options.persistConfig;
+    const shouldPersist = TsDocConfigBuilder.shouldPersist(persistConfig);
+    const tsdocConfigOutputPath = TsDocConfigBuilder.getConfigPath(persistConfig, cwd);
+    const tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions, (0, external_node_path_.dirname)(tsdocConfigOutputPath));
+    let ESLint;
+    let tsParserModule;
+    let tsdocPluginModule;
+    const missingPackages = [];
+    try {
+        const eslintModule = await import("eslint");
+        ESLint = eslintModule.ESLint;
+    } catch  {
+        missingPackages.push("eslint");
+    }
+    try {
+        tsParserModule = await import("@typescript-eslint/parser");
+    } catch  {
+        missingPackages.push("@typescript-eslint/parser");
+    }
+    try {
+        tsdocPluginModule = await import("eslint-plugin-tsdoc");
+    } catch  {
+        missingPackages.push("eslint-plugin-tsdoc");
+    }
+    if (missingPackages.length > 0 || !ESLint) throw new Error(`TsDocLintPlugin requires: ${missingPackages.join(", ")}\nInstall with: pnpm add -D ${missingPackages.join(" ")}`);
+    const tsParser = tsParserModule.default ?? tsParserModule;
+    const tsdocPlugin = tsdocPluginModule.default ?? tsdocPluginModule;
+    const discovery = discoverFilesToLint(options, cwd);
+    if (0 === discovery.files.length) return {
+        results: {
+            errorCount: 0,
+            warningCount: 0,
+            messages: []
+        },
+        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
+        discoveryErrors: discovery.errors
+    };
+    let eslintConfig;
+    let filesToLint;
+    if (discovery.isGlobPattern) {
+        const includePatterns = discovery.files;
+        filesToLint = includePatterns.filter((p)=>!p.startsWith("!"));
+        eslintConfig = [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**"
+                ]
+            },
+            {
+                files: filesToLint,
+                ignores: includePatterns.filter((p)=>p.startsWith("!")).map((p)=>p.slice(1)),
+                languageOptions: {
+                    parser: tsParser
+                },
+                plugins: {
+                    tsdoc: tsdocPlugin
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ];
+    } else {
+        filesToLint = discovery.files;
+        eslintConfig = [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**"
+                ]
+            },
+            {
+                files: [
+                    "**/*.ts",
+                    "**/*.tsx"
+                ],
+                languageOptions: {
+                    parser: tsParser
+                },
+                plugins: {
+                    tsdoc: tsdocPlugin
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ];
+    }
+    const eslint = new ESLint({
+        cwd,
+        overrideConfigFile: true,
+        overrideConfig: eslintConfig
+    });
+    const eslintResults = await eslint.lintFiles(filesToLint);
+    const messages = [];
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const result of eslintResults)for (const msg of result.messages){
+        messages.push({
+            filePath: result.filePath,
+            line: msg.line,
+            column: msg.column,
+            message: msg.message,
+            ruleId: msg.ruleId,
+            severity: msg.severity
+        });
+        if (2 === msg.severity) errorCount++;
+        else warningCount++;
+    }
+    return {
+        results: {
+            errorCount,
+            warningCount,
+            messages
+        },
+        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
+        discoveryErrors: discovery.errors.length > 0 ? discovery.errors : void 0
+    };
+}
+async function cleanupTsDocConfig(configPath) {
+    if (!configPath) return;
+    try {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(configPath);
+    } catch  {}
+}
+const TsDocLintPlugin = (options = {})=>{
+    const { enabled = true } = options;
+    let tempTsDocConfigPath;
+    return {
+        name: "tsdoc-lint-plugin",
+        setup (api) {
+            if (!enabled) return;
+            api.onBeforeBuild(async ()=>{
+                const cwd = api.context.rootPath;
+                const isCI = TsDocConfigBuilder.isCI();
+                const onError = options.onError ?? (isCI ? "throw" : "error");
+                core_logger.info(`${picocolors.dim("[tsdoc-lint]")} Validating TSDoc comments...`);
+                try {
+                    const { results, tsdocConfigPath, discoveryErrors } = await runTsDocLint(options, cwd);
+                    if (discoveryErrors && discoveryErrors.length > 0) for (const error of discoveryErrors)core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} ${error.message}`);
+                    if (!TsDocConfigBuilder.shouldPersist(options.persistConfig)) tempTsDocConfigPath = tsdocConfigPath;
+                    if (0 === results.errorCount && 0 === results.warningCount) return void core_logger.info(`${picocolors.dim("[tsdoc-lint]")} ${picocolors.green("All TSDoc comments are valid")}`);
+                    const formatted = formatLintResults(results, cwd);
+                    if (results.errorCount > 0) if ("throw" === onError) throw new Error(`TSDoc validation failed:\n${formatted}`);
+                    else if ("error" === onError) core_logger.error(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation errors:\n${formatted}`);
+                    else core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation warnings:\n${formatted}`);
+                    else if (results.warningCount > 0) core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} TSDoc validation warnings:\n${formatted}`);
+                } catch (error) {
+                    await cleanupTsDocConfig(tempTsDocConfigPath);
+                    throw error;
+                }
+            });
+            api.onCloseBuild(async ()=>{
+                await cleanupTsDocConfig(tempTsDocConfigPath);
+            });
+        }
+    };
+};
 /* v8 ignore next -- @preserve */ class NodeLibraryBuilder {
     static DEFAULT_OPTIONS = {
         entry: void 0,
@@ -1609,7 +1885,8 @@ const PackageJsonTransformPlugin = (options = {})=>{
         tsconfigPath: void 0,
         externals: [],
         dtsBundledPackages: void 0,
-        transformFiles: void 0
+        transformFiles: void 0,
+        tsdocLint: void 0
     };
     static mergeOptions(options = {}) {
         const merged = {
@@ -1643,6 +1920,11 @@ const PackageJsonTransformPlugin = (options = {})=>{
         const options = NodeLibraryBuilder.mergeOptions(opts);
         const VERSION = await packageJsonVersion();
         const plugins = [];
+        if (options.tsdocLint) {
+            const lintOptions = true === options.tsdocLint ? {} : options.tsdocLint;
+            if (!lintOptions.tsdoc && "object" == typeof options.apiModel && options.apiModel.tsdoc) lintOptions.tsdoc = options.apiModel.tsdoc;
+            plugins.push(TsDocLintPlugin(lintOptions));
+        }
         if ("dev" === target || "npm" === target) {
             if (!options.entry) plugins.push(AutoEntryPlugin({
                 exportsAsIndexes: options.exportsAsIndexes
@@ -1721,4 +2003,4 @@ const PackageJsonTransformPlugin = (options = {})=>{
         });
     }
 }
-export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, NodeLibraryBuilder, PackageJsonTransformPlugin, PackageJsonTransformer, PnpmCatalog, TsDocConfigBuilder, collectDtsFiles, ensureTempDeclarationDir, findTsConfig, generateTsgoArgs, getTsgoBinPath, getUnscopedPackageName, stripSourceMapComment };
+export { AutoEntryPlugin, DtsPlugin, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin };