@savvy-web/rslib-builder 0.8.1 → 0.10.0

package/README.md

@@ -22,6 +22,10 @@ focus on your code.
   cleaner public APIs, with multi-entry support for packages with multiple exports
 - **Multi-Target Builds** - Separate dev (source maps) and npm (optimized)
   outputs
+- **Virtual Entries** - Bundle additional files (like pnpmfile.cjs) with custom
+  output names, bypassing type generation and package.json exports
+- **Flexible Format** - Configure output format (ESM or CJS) at the library level
+  with per-entry overrides for virtual entries
 - **PNPM Integration** - Automatically resolves `catalog:` and `workspace:`
   references
 - **Package.json Transform** - Converts `.ts` exports to `.js`, generates files

package/index.d.ts

@@ -56,9 +56,12 @@ import ts from 'typescript';
 
 /**
  * Options for API model generation.
- * When enabled, generates an `<unscopedPackageName>.api.json` file using API Extractor.
+ * Generates an `<unscopedPackageName>.api.json` file using API Extractor.
  *
  * @remarks
+ * API model generation is enabled by default. To disable, set `apiModel: false`.
+ * Providing an options object implicitly enables API model generation.
+ *
  * API models are only generated for the main "index" entry point (the "." export).
  * Additional entry points like "./hooks" or "./utils" do not generate separate API models.
  * This prevents multiple conflicting API models and ensures a single source of truth
@@ -67,11 +70,6 @@ import ts from 'typescript';
  * @public
  */
 export declare interface ApiModelOptions {
-    /**
-     * Whether to enable API model generation.
-     * @defaultValue false
-     */
-    enabled?: boolean;
     /**
      * Filename for the generated API model file.
      * @defaultValue `<unscopedPackageName>.api.json` (e.g., `rslib-builder.api.json`)
@@ -94,7 +92,6 @@ export declare interface ApiModelOptions {
      * import type { ApiModelOptions } from '@savvy-web/rslib-builder';
      *
      * const apiModel: ApiModelOptions = {
-     *   enabled: true,
      *   localPaths: ['../docs-site/lib/packages/my-package'],
      * };
      * ```
@@ -114,7 +111,6 @@ export declare interface ApiModelOptions {
      * import type { ApiModelOptions } from '@savvy-web/rslib-builder';
      *
      * const apiModel: ApiModelOptions = {
-     *   enabled: true,
      *   tsdoc: {
      *     tagDefinitions: [{ tagName: '@error', syntaxKind: 'inline' }],
      *   },
@@ -132,11 +128,12 @@ export declare interface ApiModelOptions {
      * A forgotten export occurs when a public API references a declaration
      * that isn't exported from the entry point.
      *
-     * - `"include"` (default): Log a warning, include in the API model
+     * - `"include"`: Log a warning, include in the API model
      * - `"error"`: Fail the build with details about the forgotten exports
      * - `"ignore"`: Turn off detection — suppress all messages
      *
-     * @defaultValue "include"
+     * @defaultValue `"error"` in CI environments (`CI` or `GITHUB_ACTIONS` env vars),
+     *               `"include"` otherwise
      */
     forgottenExports?: "include" | "error" | "ignore";
 }
@@ -398,6 +395,13 @@ export declare interface DtsPluginOptions {
      * Used to generate the correct temp tsconfig when tsconfigPath is not provided.
      */
     buildTarget?: "dev" | "npm";
+    /**
+     * Output format for the library.
+     * Affects the resolved tsconfig.json module settings:
+     * - `"esm"`: Uses ESNext module and Bundler resolution (default)
+     * - `"cjs"`: Uses CommonJS module and Node10 resolution
+     */
+    format?: "esm" | "cjs";
     /**
      * Options for API model generation.
      * When enabled, generates an `<unscopedPackageName>.api.json` file in the dist directory.
@@ -1058,6 +1062,17 @@ export declare type JsonPrimitive = string | number | boolean | null;
  */
 export declare type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 
+/**
+ * Output format for library builds.
+ *
+ * @remarks
+ * - `"esm"` - ES Modules format (sets `type: "module"` in package.json)
+ * - `"cjs"` - CommonJS format (sets `type: "commonjs"` in package.json)
+ *
+ * @public
+ */
+export declare type LibraryFormat = "esm" | "cjs";
+
 /**
  * Allows creating a union type by combining primitive types and literal types
  * without sacrificing auto-completion in IDEs for the literal type part of the union.
@@ -1108,7 +1123,6 @@ export declare type LiteralUnion<LiteralType, BaseType extends Primitive> = Lite
  * export default NodeLibraryBuilder.create({
  *   externals: ['@rslib/core', '@rsbuild/core'],
  *   dtsBundledPackages: ['picocolors'],
- *   apiModel: true,
  *   transform({ target, pkg }) {
  *     if (target === 'npm') {
  *       delete pkg.devDependencies;
@@ -1140,7 +1154,15 @@ export declare class NodeLibraryBuilder {
      * These defaults are merged with user-provided options in {@link NodeLibraryBuilder.mergeOptions}.
      * Arrays are deep-copied to prevent mutation of this object.
      */
-    static readonly DEFAULT_OPTIONS: NodeLibraryBuilderOptions;
+    static readonly DEFAULT_OPTIONS: {
+        format: "esm";
+        plugins: never[];
+        define: {};
+        copyPatterns: never[];
+        targets: ("dev" | "npm")[];
+        externals: never[];
+        apiModel: true;
+    };
     /**
      * Merges user-provided options with default options.
      *
@@ -1176,12 +1198,65 @@ export declare class NodeLibraryBuilder {
      * @returns Promise resolving to the RSLib configuration
      */
     static createSingleTarget(target: BuildTarget, opts: NodeLibraryBuilderOptions): Promise<RslibConfig>;
+    /**
+     * Checks if the current package has exports defined in package.json.
+     * @internal
+     */
+    private static packageHasExports;
 }
 
 /**
  * @public
  */
 export declare interface NodeLibraryBuilderOptions {
+    /**
+     * Output format for main entry points.
+     * Also determines package.json `type` field:
+     * - `"esm"` → `"type": "module"`
+     * - `"cjs"` → `"type": "commonjs"`
+     *
+     * @defaultValue `"esm"`
+     */
+    format?: LibraryFormat;
+    /**
+     * Additional entry points bundled with custom output names.
+     * These entries bypass type generation and package.json exports
+     * but are included in the published package.
+     *
+     * @remarks
+     * Virtual entries are useful for special files like pnpm config files
+     * that need to be bundled but don't require type declarations or
+     * exposure as package exports.
+     *
+     * A module may have ONLY virtualEntries with no regular entry points.
+     *
+     * @example
+     * Mixed: regular entries + virtual entries
+     * ```typescript
+     * NodeLibraryBuilder.create({
+     *   virtualEntries: {
+     *     "pnpmfile.cjs": {
+     *       source: "./src/pnpmfile.ts",
+     *       format: "cjs",
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     * Virtual-only: no regular entry points
+     * ```typescript
+     * NodeLibraryBuilder.create({
+     *   format: "cjs",
+     *   virtualEntries: {
+     *     "pnpmfile.cjs": {
+     *       source: "./src/pnpmfile.ts",
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    virtualEntries?: Record<string, VirtualEntryConfig>;
     /** Override entry points (optional - will auto-detect from package.json) */
     entry?: Record<string, string | string[]>;
     /**
@@ -1316,74 +1391,39 @@ export declare interface NodeLibraryBuilderOptions {
     transform?: TransformPackageJsonFn;
     /**
      * Options for API model generation.
-     * When enabled, generates an `<unscopedPackageName>.api.json` file in the dist directory.
+     * Generates an `<unscopedPackageName>.api.json` file in the dist directory.
      * Only applies when target is "npm".
      *
      * @remarks
-     * The generated API model file contains the full API documentation
-     * in a machine-readable format for use by documentation generators.
+     * API model generation is **enabled by default**. The generated file contains
+     * full API documentation in a machine-readable format for documentation generators.
      * The file is emitted to dist but excluded from npm publish (added as negated pattern in `files` array).
      *
+     * @defaultValue true
+     *
      * @example
-     * Enable API model generation with defaults:
+     * Disable API model generation:
      * ```typescript
      * import { NodeLibraryBuilder } from '@savvy-web/rslib-builder';
      *
      * export default NodeLibraryBuilder.create({
-     *   apiModel: true,
+     *   apiModel: false,
      * });
      * ```
      *
      * @example
-     * Enable with custom filename:
+     * Customize with options (implicitly enabled):
      * ```typescript
      * import { NodeLibraryBuilder } from '@savvy-web/rslib-builder';
      *
      * export default NodeLibraryBuilder.create({
      *   apiModel: {
-     *     enabled: true,
      *     filename: 'my-package.api.json',
      *   },
      * });
      * ```
      */
     apiModel?: ApiModelOptions | boolean;
-    /**
-     * Options for TSDoc lint validation.
-     * When enabled, validates TSDoc comments before the build starts.
-     *
-     * @remarks
-     * Uses ESLint with `eslint-plugin-tsdoc` to validate TSDoc syntax.
-     * By default, throws errors in CI environments and logs errors locally.
-     * The generated `tsdoc.json` config is persisted locally for IDE integration.
-     *
-     * @example
-     * Enable with defaults (throws in CI, errors locally):
-     * ```typescript
-     * import { NodeLibraryBuilder } from '@savvy-web/rslib-builder';
-     *
-     * export default NodeLibraryBuilder.create({
-     *   tsdocLint: true,
-     * });
-     * ```
-     *
-     * @example
-     * Enable with custom configuration:
-     * ```typescript
-     * import { NodeLibraryBuilder } from '@savvy-web/rslib-builder';
-     *
-     * export default NodeLibraryBuilder.create({
-     *   tsdocLint: {
-     *     tsdoc: {
-     *       tagDefinitions: [{ tagName: '@error', syntaxKind: 'block' }],
-     *     },
-     *     onError: 'throw',
-     *     persistConfig: true,
-     *   },
-     * });
-     * ```
-     */
-    tsdocLint?: TsDocLintPluginOptions | boolean;
 }
 
 /**
@@ -1880,6 +1920,15 @@ export declare const PackageJsonTransformPlugin: (options?: PackageJsonTransform
  * @public
  */
 export declare interface PackageJsonTransformPluginOptions {
+    /**
+     * Output format for the library.
+     * Determines the package.json `type` field:
+     * - `"esm"` → `"type": "module"`
+     * - `"cjs"` → `"type": "commonjs"`
+     *
+     * @defaultValue `"esm"`
+     */
+    format?: LibraryFormat;
     /**
      * Override the package name in the output package.json.
      *
@@ -2364,8 +2413,14 @@ export declare class TsconfigResolver {
      * - Excludes file selection (include, exclude, files, references)
      * - Adds $schema for IDE support
      *
+     * When `format` is `"cjs"`, the resolved config uses CommonJS-compatible settings:
+     * - `module: "commonjs"`
+     * - `moduleResolution: "node10"`
+     * - `esModuleInterop: true`
+     *
      * @param parsed - The parsed TypeScript configuration from `parseJsonConfigFileContent`
      * @param _rootDir - Reserved for future path normalization (currently unused)
+     * @param format - Optional output format to adjust module settings (`"esm"` or `"cjs"`)
      * @returns A JSON-serializable tsconfig object
      * @throws {@link TsconfigResolverError} If resolution fails for any option
          *
@@ -2385,7 +2440,7 @@ export declare class TsconfigResolver {
          *
          * @public
          */
-     resolve(parsed: ParsedCommandLine, _rootDir: string): ResolvedTsconfig;
+     resolve(parsed: ParsedCommandLine, _rootDir: string, format?: LibraryFormat): ResolvedTsconfig;
      /**
       * Adds converted enum options to the compiler options object.
       * @internal
@@ -2567,9 +2622,14 @@ export declare class TsconfigResolver {
          *
          * In CI environments (`CI` or `GITHUB_ACTIONS` env vars set to "true"),
          * this method validates the existing file instead of writing, throwing
-         * an error if the config is out of date.
+         * an error if the config is out of date. Set `skipCIValidation` to true
+         * to skip this validation (useful when `persistConfig: false`).
+         *
+         * @param options - TSDoc configuration options
+         * @param outputDir - Directory to write the config file
+         * @param skipCIValidation - Skip CI validation even in CI environments
          */
-        static writeConfigFile(options: TsDocOptions | undefined, outputDir: string): Promise<string>;
+        static writeConfigFile(options: TsDocOptions | undefined, outputDir: string, skipCIValidation?: boolean): Promise<string>;
         /** Converts TSDocTagSyntaxKind enum to string format. */
         private static syntaxKindToString;
     }
@@ -2586,6 +2646,54 @@ export declare class TsconfigResolver {
      */
     export declare type TsDocLintErrorBehavior = "warn" | "error" | "throw";
 
+    /**
+     * Options for TSDoc lint validation (subset of TsDocLintPluginOptions).
+     * TSDoc configuration is inherited from the parent TsDocOptions.
+     *
+     * @public
+     */
+    export declare interface TsDocLintOptions {
+        /**
+         * Override automatic file discovery with explicit file paths or glob patterns.
+         *
+         * @remarks
+         * By default, uses import graph analysis to discover files from your package's exports.
+         * This ensures only public API files are linted.
+         *
+         * @example
+         * ```typescript
+         * lint: {
+         *   include: ["src/**\/*.ts", "!**\/*.test.ts"],
+         * }
+         * ```
+         */
+        include?: string[];
+        /**
+         * How to handle TSDoc lint errors.
+         * - `"warn"`: Log warnings but continue the build
+         * - `"error"`: Log errors but continue the build
+         * - `"throw"`: Fail the build with an error
+         *
+         * @defaultValue `"throw"` in CI environments, `"error"` locally
+         */
+        onError?: TsDocLintErrorBehavior;
+        /**
+         * Persist tsdoc.json to disk for tool integration (ESLint, IDEs).
+         * - `true`: Write to project root as "tsdoc.json" (or validate in CI)
+         * - `PathLike`: Write to specified path (or validate in CI)
+         * - `false`: Clean up after linting (not recommended)
+         *
+         * @remarks
+         * In CI environments (`CI` or `GITHUB_ACTIONS` env vars set to "true"),
+         * the config file is validated instead of written. If the existing file
+         * doesn't match the expected configuration, the build fails with an error
+         * instructing the developer to regenerate the file locally.
+         *
+         * @defaultValue `true`
+         */
+        persistConfig?: boolean | PathLike;
+    }
+
     /**
      * Creates a plugin to validate TSDoc comments before build using ESLint with eslint-plugin-tsdoc.
      *
@@ -2815,21 +2923,6 @@ export declare class TsconfigResolver {
          * ```
          */
         supportForTags?: Record<string, boolean>;
-        /**
-         * Persist tsdoc.json to disk for tool integration (ESLint, IDEs).
-         * - `true`: Write to project root as "tsdoc.json" (or validate in CI)
-         * - `PathLike`: Write to specified path (or validate in CI)
-         * - `false`: Clean up after API Extractor (not recommended)
-         *
-         * @remarks
-         * In CI environments (`CI` or `GITHUB_ACTIONS` env vars set to "true"),
-         * the config file is validated instead of written. If the existing file
-         * doesn't match the expected configuration, the build fails with an error
-         * instructing the developer to regenerate the file locally.
-         *
-         * @defaultValue `true`
-         */
-        persistConfig?: boolean | PathLike;
         /**
          * How to handle TSDoc validation warnings from API Extractor.
          * - `"log"`: Show warnings in the console but continue the build
@@ -2849,6 +2942,42 @@ export declare class TsconfigResolver {
          *               `"log"` otherwise
          */
         warnings?: "log" | "fail" | "none";
+        /**
+         * TSDoc lint validation options.
+         * Validates TSDoc comments before the build starts using ESLint.
+         *
+         * @remarks
+         * Lint validation is **enabled by default**. Set to `false` to disable.
+         * When enabled, it uses the parent TSDoc configuration (tagDefinitions, groups, etc.)
+         * for validation rules.
+         *
+         * @defaultValue true
+         *
+         * @example
+         * Disable lint validation:
+         * ```typescript
+         * apiModel: {
+         *   tsdoc: {
+         *     lint: false,
+         *   },
+         * }
+         * ```
+         *
+         * @example
+         * Customize lint behavior:
+         * ```typescript
+         * apiModel: {
+         *   tsdoc: {
+         *     tagDefinitions: [{ tagName: '@error', syntaxKind: 'inline' }],
+         *     lint: {
+         *       onError: 'throw',
+         *       include: ['src/**\/*.ts'],
+         *     },
+         *   },
+         * }
+         * ```
+         */
+        lint?: TsDocLintOptions | boolean;
     }
 
     /**
@@ -2891,4 +3020,72 @@ export declare class TsconfigResolver {
      */
     export declare type TsDocTagGroup = "core" | "extended" | "discretionary";
 
+    /**
+     * Configuration for a virtual entry point.
+     *
+     * @remarks
+     * Virtual entries are bundled entry points that bypass type generation
+     * and package.json exports while still being included in the published package.
+     *
+     * @example
+     * ```typescript
+     * const config: VirtualEntryConfig = {
+     *   source: "./src/pnpmfile.ts",
+     *   format: "cjs",
+     * };
+     * ```
+     *
+     * @public
+     */
+    export declare interface VirtualEntryConfig {
+        /**
+         * Path to source file (relative to package root).
+         */
+        source: string;
+        /**
+         * Output format for this entry.
+         * If not specified, inherits from top-level `format` option.
+         */
+        format?: LibraryFormat;
+    }
+
+    /**
+     * Plugin to handle virtual entry points in RSlib builds.
+     *
+     * @remarks
+     * Virtual entries are special entry points that:
+     * - Are bundled like regular entries
+     * - Do NOT generate TypeScript declarations (.d.ts files)
+     * - Are NOT added to package.json exports
+     * - ARE added to package.json files array for publishing
+     *
+     * This plugin:
+     * 1. Exposes the virtual entry names for DtsPlugin to skip type generation
+     * 2. Adds virtual entry outputs to the files array in the additional stage
+     *
+     * @example
+     * ```typescript
+     * import { VirtualEntryPlugin } from '@savvy-web/rslib-builder';
+     *
+     * const plugin = VirtualEntryPlugin({
+     *   virtualEntryNames: new Set(['pnpmfile']),
+     * });
+     * ```
+     *
+     * @public
+     */
+    export declare const VirtualEntryPlugin: (options: VirtualEntryPluginOptions) => RsbuildPlugin;
+
+    /**
+     * Options for the VirtualEntryPlugin.
+     * @public
+     */
+    export declare interface VirtualEntryPluginOptions {
+        /**
+         * Set of virtual entry names (without extensions).
+         * Used by DtsPlugin to skip type generation for these entries.
+         */
+        virtualEntryNames: Set<string>;
+    }
+
     export { }

package/index.js

@@ -1,11 +1,11 @@
 /*! For license information please see index.js.LICENSE.txt */
-import { constants, existsSync, writeFileSync } from "node:fs";
+import { constants, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, normalize, relative, resolve as external_node_path_resolve } from "node:path";
 import { defineConfig } from "@rslib/core";
 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 { getWorkspaceManagerRoot } from "workspace-tools";
 import { spawn } from "node:child_process";
 import { StandardTags, Standardization, TSDocTagSyntaxKind } from "@microsoft/tsdoc";
 import deep_equal from "deep-equal";
@@ -169,7 +169,7 @@ function getApiExtractorPath() {
     const cwd = process.cwd();
     const localApiExtractor = join(cwd, "node_modules", "@microsoft", "api-extractor");
     if (existsSync(localApiExtractor)) return localApiExtractor;
-    const workspaceRoot = getWorkspaceRoot(cwd);
+    const workspaceRoot = getWorkspaceManagerRoot(cwd);
     if (workspaceRoot) {
         const workspaceApiExtractor = join(workspaceRoot, "node_modules", "@microsoft", "api-extractor");
         if (existsSync(workspaceApiExtractor)) return workspaceApiExtractor;
@@ -205,9 +205,9 @@ const AutoEntryPlugin = (options)=>{
                 try {
                     const packageJsonContent = await readFile(assetPath, "utf-8");
                     const packageJson = JSON.parse(packageJsonContent);
-                    const { entries } = extractEntriesFromPackageJson(packageJson, {
-                        exportsAsIndexes: options?.exportsAsIndexes
-                    });
+                    const { entries } = extractEntriesFromPackageJson(packageJson, options?.exportsAsIndexes != null ? {
+                        exportsAsIndexes: options.exportsAsIndexes
+                    } : void 0);
                     if (options?.exportsAsIndexes && packageJson.exports) {
                         const exports = packageJson.exports;
                         if ("object" == typeof exports && !Array.isArray(exports)) for (const pkgExportKey of Object.keys(exports)){
@@ -255,7 +255,7 @@ 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":false,"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 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":false,"isolatedModules":true,"exactOptionalPropertyTypes":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"]}');
 const requireCJS = createRequire(import.meta.url);
 const jsonImports = new Map([
     [
@@ -320,28 +320,43 @@ class LibraryTSConfigFile extends TSConfigFile {
                 outDir: "dist",
                 tsBuildInfoFile: `${process.cwd()}/dist/.tsbuildinfo.${target}.bundle`
             },
-            include
+            ...void 0 !== include && include.length > 0 ? {
+                include
+            } : {}
         };
     }
-    writeBundleTempConfig(target) {
+    writeBundleTempConfig(_target) {
         const cwd = process.cwd();
-        const config = this.bundle(target);
-        const toAbsolute = (path)=>{
-            if (path.startsWith("../") || ".." === path) return path.replace(/^((\.\.\/)+\.\.?|\.\.\/*)$/, cwd).replace(/^(\.\.\/)+/, `${cwd}/`);
-            return path;
-        };
+        const baseConfig = this.config;
         const absoluteConfig = {
-            ...config,
+            $schema: "https://json.schemastore.org/tsconfig.json",
             compilerOptions: {
-                ...config.compilerOptions,
+                ...baseConfig.compilerOptions,
+                composite: false,
+                incremental: false,
+                tsBuildInfoFile: void 0,
                 rootDir: cwd,
+                outDir: join(cwd, "dist"),
+                declarationDir: join(cwd, "dist"),
+                typeRoots: [
+                    join(cwd, "node_modules/@types"),
+                    join(cwd, "types")
+                ],
                 declarationMap: true,
-                emitDeclarationOnly: false,
-                declarationDir: config.compilerOptions?.declarationDir ? toAbsolute(config.compilerOptions.declarationDir) : void 0,
-                typeRoots: config.compilerOptions?.typeRoots?.map(toAbsolute)
+                emitDeclarationOnly: false
             },
-            include: config.include?.map(toAbsolute),
-            exclude: config.exclude?.map(toAbsolute)
+            include: [
+                join(cwd, "src/**/*.ts"),
+                join(cwd, "src/**/*.mts"),
+                join(cwd, "src/**/*.tsx"),
+                join(cwd, "src/**/*.json"),
+                join(cwd, "types/*.ts"),
+                join(cwd, "package.json")
+            ],
+            exclude: [
+                join(cwd, "node_modules"),
+                join(cwd, "dist/**/*")
+            ]
         };
         const tmpFile = requireCJS("tmp").fileSync({
             prefix: "tsconfig-bundle-",
@@ -365,8 +380,8 @@ class TsconfigResolverError extends Error {
     constructor(message, option, value){
         super(message);
         this.name = "TsconfigResolverError";
-        this.option = option;
-        this.value = value;
+        if (void 0 !== option) this.option = option;
+        if (void 0 !== value) this.value = value;
     }
 }
 const TSCONFIG_SCHEMA_URL = "https://json.schemastore.org/tsconfig";
@@ -664,7 +679,7 @@ class TsconfigResolver {
         const filename = lib.includes("/") || lib.includes("\\") ? lib.split(/[\\/]/).pop() ?? lib : lib;
         return filename.replace(/^lib\./, "").replace(/\.d\.ts$/, "");
     }
-    resolve(parsed, _rootDir) {
+    resolve(parsed, _rootDir, format) {
         const opts = parsed.options;
         const compilerOptions = {};
         this.addEnumOptions(compilerOptions, opts);
@@ -673,6 +688,11 @@ class TsconfigResolver {
         compilerOptions.noEmit = true;
         this.addPreservedBooleanOptions(compilerOptions, opts);
         this.addPreservedStringOptions(compilerOptions, opts);
+        if ("cjs" === format) {
+            compilerOptions.module = "commonjs";
+            compilerOptions.moduleResolution = "node10";
+            compilerOptions.esModuleInterop = true;
+        }
         return {
             $schema: TSCONFIG_SCHEMA_URL,
             compilerOptions
@@ -786,9 +806,9 @@ class TsDocConfigBuilder {
             strict: true
         })) throw new Error(`tsdoc.json is out of date. Run the build locally to regenerate it, then commit the changes.\nExpected:\n${JSON.stringify(expectedConfig, null, 2)}\n\nActual:\n${JSON.stringify(existingConfig, null, 2)}`);
     }
-    static async writeConfigFile(options = {}, outputDir) {
+    static async writeConfigFile(options = {}, outputDir, skipCIValidation = false) {
         const configPath = join(outputDir, "tsdoc.json");
-        if (TsDocConfigBuilder.isCI()) {
+        if (TsDocConfigBuilder.isCI() && !skipCIValidation) {
             await TsDocConfigBuilder.validateConfigFile(options, configPath);
             return configPath;
         }
@@ -821,7 +841,7 @@ function getTsgoBinPath() {
     const cwd = process.cwd();
     const localTsgoBin = join(cwd, "node_modules", ".bin", "tsgo");
     if (existsSync(localTsgoBin)) return localTsgoBin;
-    const workspaceRoot = getWorkspaceRoot(cwd);
+    const workspaceRoot = getWorkspaceManagerRoot(cwd);
     if (workspaceRoot) {
         const workspaceTsgoBin = join(workspaceRoot, "node_modules", ".bin", "tsgo");
         if (existsSync(workspaceTsgoBin)) return workspaceTsgoBin;
@@ -869,25 +889,27 @@ async function bundleDtsFiles(options) {
     const bundledFiles = new Map();
     let apiModelPath;
     let tsdocMetadataPath;
-    const apiModelEnabled = true === apiModel || "object" == typeof apiModel && (void 0 === apiModel.enabled || true === apiModel.enabled);
+    const apiModelEnabled = true === apiModel || "object" == typeof apiModel;
     const apiModelFilename = "object" == typeof apiModel && apiModel.filename ? apiModel.filename : "api.json";
     const tsdocOptions = "object" == typeof apiModel ? apiModel.tsdoc : void 0;
     const tsdocMetadataOption = "object" == typeof apiModel ? apiModel.tsdocMetadata : void 0;
     const tsdocWarnings = tsdocOptions?.warnings ?? (TsDocConfigBuilder.isCI() ? "fail" : "log");
-    const forgottenExports = ("object" == typeof apiModel ? apiModel.forgottenExports : void 0) ?? "include";
+    const forgottenExports = ("object" == typeof apiModel ? apiModel.forgottenExports : void 0) ?? (TsDocConfigBuilder.isCI() ? "error" : "include");
     const tsdocMetadataEnabled = apiModelEnabled && (void 0 === tsdocMetadataOption || true === tsdocMetadataOption || "object" == typeof tsdocMetadataOption && false !== tsdocMetadataOption.enabled);
     const tsdocMetadataFilename = "object" == typeof tsdocMetadataOption && tsdocMetadataOption.filename ? tsdocMetadataOption.filename : "tsdoc-metadata.json";
     getApiExtractorPath();
-    const persistConfig = tsdocOptions?.persistConfig;
+    const lintConfig = "object" == typeof tsdocOptions?.lint ? tsdocOptions.lint : void 0;
+    const persistConfig = lintConfig?.persistConfig;
     const tsdocConfigOutputPath = TsDocConfigBuilder.getConfigPath(persistConfig, cwd);
+    const skipCIValidation = false === persistConfig;
     let tsdocConfigPath;
     let tsdocConfigFile;
     if (apiModelEnabled) {
-        tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions ?? {}, dirname(tsdocConfigOutputPath));
+        tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions ?? {}, dirname(tsdocConfigOutputPath), skipCIValidation);
         const { TSDocConfigFile } = await import("@microsoft/tsdoc-config");
         tsdocConfigFile = TSDocConfigFile.loadForFolder(dirname(tsdocConfigPath));
     }
-    const { Extractor, ExtractorConfig } = await import("@microsoft/api-extractor");
+    const { Extractor, ExtractorConfig, ExtractorMessage, ExtractorLogLevel } = await import("@microsoft/api-extractor");
     for (const [entryName, sourcePath] of entryPoints){
         const normalizedSourcePath = sourcePath.replace(/^\.\//, "");
         const dtsFileName = normalizedSourcePath.replace(/\.(tsx?|jsx?)$/, ".d.ts");
@@ -910,7 +932,7 @@ async function bundleDtsFiles(options) {
         const tempApiModelPath = generateApiModel ? join(tempOutputDir, apiModelFilename) : void 0;
         const generateTsdocMetadata = tsdocMetadataEnabled && "index" === entryName;
         const tempTsdocMetadataPath = generateTsdocMetadata ? join(tempOutputDir, tsdocMetadataFilename) : void 0;
-        const extractorConfig = ExtractorConfig.prepare({
+        const prepareOptions = {
             configObject: {
                 projectFolder: cwd,
                 mainEntryPointFilePath: tempDtsPath,
@@ -922,20 +944,29 @@ async function bundleDtsFiles(options) {
                     enabled: true,
                     untrimmedFilePath: tempBundledPath
                 },
-                docModel: generateApiModel ? {
-                    enabled: true,
-                    apiJsonFilePath: tempApiModelPath
-                } : void 0,
-                tsdocMetadata: generateTsdocMetadata ? {
-                    enabled: true,
-                    tsdocMetadataFilePath: tempTsdocMetadataPath
-                } : void 0,
+                ...generateApiModel && {
+                    docModel: {
+                        enabled: true,
+                        ...tempApiModelPath && {
+                            apiJsonFilePath: tempApiModelPath
+                        }
+                    }
+                },
+                ...generateTsdocMetadata && {
+                    tsdocMetadata: {
+                        enabled: true,
+                        ...tempTsdocMetadataPath && {
+                            tsdocMetadataFilePath: tempTsdocMetadataPath
+                        }
+                    }
+                },
                 bundledPackages: bundledPackages
             },
             packageJsonFullPath: join(cwd, "package.json"),
-            configObjectFullPath: void 0,
-            tsdocConfigFile: tsdocConfigFile
-        });
+            configObjectFullPath: void 0
+        };
+        if (tsdocConfigFile) prepareOptions.tsdocConfigFile = tsdocConfigFile;
+        const extractorConfig = ExtractorConfig.prepare(prepareOptions);
         const collectedTsdocWarnings = [];
         const collectedForgottenExports = [];
         const extractorResult = Extractor.invoke(extractorConfig, {
@@ -943,33 +974,45 @@ async function bundleDtsFiles(options) {
             showVerboseMessages: false,
             messageCallback: (message)=>{
                 if (message.text?.includes("Analysis will use the bundled TypeScript version") || message.text?.includes("The target project appears to use TypeScript")) {
-                    message.logLevel = "none";
+                    message.logLevel = ExtractorLogLevel.None;
                     return;
                 }
                 if (message.text?.includes("You have changed the public API signature")) {
-                    message.logLevel = "none";
+                    message.logLevel = ExtractorLogLevel.None;
                     return;
                 }
                 const isTsdocMessage = message.messageId?.startsWith("tsdoc-");
-                if (isTsdocMessage && message.text) if ("none" === tsdocWarnings) message.logLevel = "none";
+                if (isTsdocMessage && message.text) if ("none" === tsdocWarnings) message.logLevel = ExtractorLogLevel.None;
                 else {
                     collectedTsdocWarnings.push({
                         text: message.text,
-                        sourceFilePath: message.sourceFilePath,
-                        sourceFileLine: message.sourceFileLine,
-                        sourceFileColumn: message.sourceFileColumn
+                        ...null != message.sourceFilePath && {
+                            sourceFilePath: message.sourceFilePath
+                        },
+                        ...null != message.sourceFileLine && {
+                            sourceFileLine: message.sourceFileLine
+                        },
+                        ...null != message.sourceFileColumn && {
+                            sourceFileColumn: message.sourceFileColumn
+                        }
                     });
-                    message.logLevel = "none";
+                    message.logLevel = ExtractorLogLevel.None;
                 }
-                if ("ae-forgotten-export" === message.messageId && message.text) if ("ignore" === forgottenExports) message.logLevel = "none";
+                if ("ae-forgotten-export" === message.messageId && message.text) if ("ignore" === forgottenExports) message.logLevel = ExtractorLogLevel.None;
                 else {
                     collectedForgottenExports.push({
                         text: message.text,
-                        sourceFilePath: message.sourceFilePath,
-                        sourceFileLine: message.sourceFileLine,
-                        sourceFileColumn: message.sourceFileColumn
+                        ...null != message.sourceFilePath && {
+                            sourceFilePath: message.sourceFilePath
+                        },
+                        ...null != message.sourceFileLine && {
+                            sourceFileLine: message.sourceFileLine
+                        },
+                        ...null != message.sourceFileColumn && {
+                            sourceFileColumn: message.sourceFileColumn
+                        }
                     });
-                    message.logLevel = "none";
+                    message.logLevel = ExtractorLogLevel.None;
                 }
             }
         });
@@ -1009,9 +1052,15 @@ async function bundleDtsFiles(options) {
     }
     return {
         bundledFiles,
-        apiModelPath,
-        tsdocMetadataPath,
-        tsdocConfigPath
+        ...apiModelPath && {
+            apiModelPath
+        },
+        ...tsdocMetadataPath && {
+            tsdocMetadataPath
+        },
+        ...tsdocConfigPath && {
+            tsdocConfigPath
+        }
     };
 }
 function stripSourceMapComment(content) {
@@ -1045,8 +1094,12 @@ function runTsgo(options) {
     const args = generateTsgoArgs({
         configPath,
         declarationDir,
-        rootDir,
-        tsBuildInfoFile
+        ...rootDir && {
+            rootDir
+        },
+        ...tsBuildInfoFile && {
+            tsBuildInfoFile
+        }
     });
     return new Promise((resolve)=>{
         const child = spawn(tsgoBinPath, args, {
@@ -1098,17 +1151,16 @@ function runTsgo(options) {
                 const log = createEnvLogger("dts");
                 const cwd = api.context.rootPath;
                 try {
-                    let configTsconfigPath = options.tsconfigPath || config.source?.tsconfigPath;
-                    if (!configTsconfigPath && options.buildTarget) {
+                    let configTsconfigPath = options.tsconfigPath;
+                    if (options.buildTarget) {
                         const originalCwd = process.cwd();
                         try {
                             process.chdir(cwd);
                             configTsconfigPath = TSConfigs.node.ecma.lib.writeBundleTempConfig(options.buildTarget);
-                            log.global.info(`Using tsconfig: ${configTsconfigPath}`);
                         } finally{
                             process.chdir(originalCwd);
                         }
-                    }
+                    } else if (!configTsconfigPath) configTsconfigPath = config.source?.tsconfigPath;
                     state.tsconfigPath = findTsConfig(cwd, configTsconfigPath);
                     if (!state.tsconfigPath) {
                         const error = new Error(`Failed to resolve tsconfig file ${picocolors.cyan(`"${config.source?.tsconfigPath ?? "tsconfig.json"}"`)} from ${picocolors.cyan(cwd)}. Please ensure that the file exists.`);
@@ -1137,8 +1189,12 @@ function runTsgo(options) {
                     const { success, output } = await runTsgo({
                         configPath: state.tsconfigPath,
                         declarationDir: tempDtsDir,
-                        rootDir: state.parsedConfig.options.rootDir,
-                        tsBuildInfoFile: state.parsedConfig.options.tsBuildInfoFile,
+                        ...state.parsedConfig.options.rootDir && {
+                            rootDir: state.parsedConfig.options.rootDir
+                        },
+                        ...state.parsedConfig.options.tsBuildInfoFile && {
+                            tsBuildInfoFile: state.parsedConfig.options.tsBuildInfoFile
+                        },
                         name: envId
                     });
                     if (!success) {
@@ -1189,8 +1245,13 @@ function runTsgo(options) {
                         const extractor = new EntryExtractor();
                         const { entries } = extractor.extract(packageJson);
                         const entryPoints = new Map();
+                        const virtualEntryNames = api.useExposed("virtual-entry-names");
                         for (const [entryName, sourcePath] of Object.entries(entries)){
                             if (entryName.startsWith("bin/")) continue;
+                            if (virtualEntryNames?.has(entryName)) {
+                                log.global.info(`Skipping type generation for virtual entry: ${entryName}`);
+                                continue;
+                            }
                             if (!sourcePath.match(/\.(ts|mts|cts|tsx)$/)) continue;
                             if (sourcePath.includes(".test.") || sourcePath.includes("__test__")) continue;
                             const resolvedSourcePath = sourcePath.startsWith(".") ? join(cwd, sourcePath) : sourcePath;
@@ -1218,9 +1279,15 @@ function runTsgo(options) {
                                 tsconfigPath: state.tsconfigPath,
                                 bundledPackages: options.bundledPackages || [],
                                 entryPoints,
-                                banner: options.banner,
-                                footer: options.footer,
-                                apiModel: options.apiModel
+                                ...options.banner && {
+                                    banner: options.banner
+                                },
+                                ...options.footer && {
+                                    footer: options.footer
+                                },
+                                ...void 0 !== options.apiModel && {
+                                    apiModel: options.apiModel
+                                }
                             });
                             let emittedCount = 0;
                             for (const [entryName, tempBundledPath] of bundledFiles){
@@ -1275,7 +1342,7 @@ function runTsgo(options) {
                             }
                             if (apiModelPath && state.parsedConfig && state.tsconfigPath) {
                                 const resolver = new TsconfigResolver();
-                                const resolvedTsconfig = resolver.resolve(state.parsedConfig, cwd);
+                                const resolvedTsconfig = resolver.resolve(state.parsedConfig, cwd, options.format);
                                 const tsconfigContent = `${JSON.stringify(resolvedTsconfig, null, "\t")}\n`;
                                 const tsconfigSource = new context.sources.OriginalSource(tsconfigContent, "tsconfig.json");
                                 context.compilation.emitAsset("tsconfig.json", tsconfigSource);
@@ -1521,7 +1588,7 @@ class PnpmCatalog {
     async getCatalog() {
         try {
             if (!this.cachedWorkspaceRoot) {
-                this.cachedWorkspaceRoot = getWorkspaceRoot(process.cwd());
+                this.cachedWorkspaceRoot = getWorkspaceManagerRoot(process.cwd());
                 if (!this.cachedWorkspaceRoot) throw new Error("Could not find workspace root - ensure you're in a workspace");
             }
             const workspaceFile = external_node_path_resolve(this.cachedWorkspaceRoot, "pnpm-workspace.yaml");
@@ -1742,7 +1809,10 @@ function applyRslibTransformations(packageJson, originalPackageJson, processTSEx
         private: isPrivate
     };
     if (processedManifest.exports) processedManifest.exports = transformPackageExports(processedManifest.exports, processTSExports, void 0, entrypoints, exportToOutputMap, bundle ?? false);
-    if (processedManifest.bin) processedManifest.bin = transformPackageBin(processedManifest.bin, processTSExports);
+    if (processedManifest.bin) {
+        const transformedBin = transformPackageBin(processedManifest.bin, processTSExports);
+        if (transformedBin) processedManifest.bin = transformedBin;
+    }
     if (originalPackageJson.typesVersions) {
         const transformedTypesVersions = {};
         for (const [version, paths] of Object.entries(originalPackageJson.typesVersions)){
@@ -1804,6 +1874,7 @@ const PackageJsonTransformPlugin = (options = {})=>{
                 const processedPackageJson = await buildPackageJson(packageJson.data, isProduction, options.processTSExports, entrypoints, exportToOutputMap, options.bundle, options.transform);
                 packageJson.data = processedPackageJson;
                 if (options.forcePrivate) packageJson.data.private = true;
+                if (options.format) packageJson.data.type = "esm" === options.format ? "module" : "commonjs";
                 const useRollupTypes = api.useExposed("use-rollup-types");
                 if (useRollupTypes && packageJson.data.exports && "object" == typeof packageJson.data.exports) {
                     const exports = packageJson.data.exports;
@@ -2091,7 +2162,8 @@ async function runTsDocLint(options, cwd) {
     const persistConfig = options.persistConfig;
     const shouldPersist = TsDocConfigBuilder.shouldPersist(persistConfig);
     const tsdocConfigOutputPath = TsDocConfigBuilder.getConfigPath(persistConfig, cwd);
-    const tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions, dirname(tsdocConfigOutputPath));
+    const skipCIValidation = false === persistConfig;
+    const tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions, dirname(tsdocConfigOutputPath), skipCIValidation);
     const eslintModule = await import("eslint");
     const tsParserModule = await import("@typescript-eslint/parser");
     const tsdocPluginModule = await import("eslint-plugin-tsdoc");
@@ -2105,8 +2177,12 @@ async function runTsDocLint(options, cwd) {
             warningCount: 0,
             messages: []
         },
-        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
-        discoveryErrors: discovery.errors
+        ...shouldPersist && {
+            tsdocConfigPath
+        },
+        ...discovery.errors.length > 0 && {
+            discoveryErrors: discovery.errors
+        }
     };
     let eslintConfig;
     let filesToLint;
@@ -2189,8 +2265,12 @@ async function runTsDocLint(options, cwd) {
             warningCount,
             messages
         },
-        tsdocConfigPath: shouldPersist ? tsdocConfigPath : void 0,
-        discoveryErrors: discovery.errors.length > 0 ? discovery.errors : void 0
+        ...shouldPersist && {
+            tsdocConfigPath
+        },
+        ...discovery.errors.length > 0 && {
+            discoveryErrors: discovery.errors
+        }
     };
 }
 async function cleanupTsDocConfig(configPath) {
@@ -2233,13 +2313,35 @@ const TsDocLintPlugin = (options = {})=>{
         }
     };
 };
+const VirtualEntryPlugin = (options)=>{
+    const { virtualEntryNames } = options;
+    return {
+        name: "virtual-entry-plugin",
+        setup (api) {
+            api.expose("virtual-entry-names", virtualEntryNames);
+            api.processAssets({
+                stage: "additional"
+            }, async (context)=>{
+                let filesArray = api.useExposed("files-array");
+                if (!filesArray) {
+                    filesArray = new Set();
+                    api.expose("files-array", filesArray);
+                }
+                for (const assetName of Object.keys(context.compilation.assets)){
+                    const baseName = assetName.replace(/\.(c|m)?js$/, "");
+                    if (virtualEntryNames.has(baseName)) filesArray.add(assetName);
+                }
+            });
+        }
+    };
+};
 /* v8 ignore next -- @preserve */ class NodeLibraryBuilder {
     static VALID_TARGETS = [
         "dev",
         "npm"
     ];
     static DEFAULT_OPTIONS = {
-        entry: void 0,
+        format: "esm",
         plugins: [],
         define: {},
         copyPatterns: [],
@@ -2247,25 +2349,46 @@ const TsDocLintPlugin = (options = {})=>{
             "dev",
             "npm"
         ],
-        tsconfigPath: void 0,
         externals: [],
-        dtsBundledPackages: void 0,
-        transformFiles: void 0,
-        tsdocLint: void 0
+        apiModel: true
     };
     static mergeOptions(options = {}) {
-        const merged = {
-            ...NodeLibraryBuilder.DEFAULT_OPTIONS,
-            ...options,
-            copyPatterns: [
-                ...options.copyPatterns ?? NodeLibraryBuilder.DEFAULT_OPTIONS.copyPatterns
-            ]
-        };
-        if (existsSync(join(process.cwd(), "public"))) merged.copyPatterns.unshift({
+        const copyPatterns = [
+            ...options.copyPatterns ?? NodeLibraryBuilder.DEFAULT_OPTIONS.copyPatterns
+        ];
+        if (existsSync(join(process.cwd(), "public"))) copyPatterns.unshift({
             from: "./public",
             to: "./",
             context: process.cwd()
         });
+        const merged = {
+            copyPatterns,
+            plugins: options.plugins ?? NodeLibraryBuilder.DEFAULT_OPTIONS.plugins,
+            define: options.define ?? NodeLibraryBuilder.DEFAULT_OPTIONS.define,
+            tsconfigPath: options.tsconfigPath,
+            format: options.format ?? NodeLibraryBuilder.DEFAULT_OPTIONS.format,
+            targets: options.targets ?? NodeLibraryBuilder.DEFAULT_OPTIONS.targets,
+            externals: options.externals ?? NodeLibraryBuilder.DEFAULT_OPTIONS.externals,
+            apiModel: options.apiModel ?? NodeLibraryBuilder.DEFAULT_OPTIONS.apiModel,
+            ...void 0 !== options.entry && {
+                entry: options.entry
+            },
+            ...void 0 !== options.exportsAsIndexes && {
+                exportsAsIndexes: options.exportsAsIndexes
+            },
+            ...void 0 !== options.dtsBundledPackages && {
+                dtsBundledPackages: options.dtsBundledPackages
+            },
+            ...void 0 !== options.transformFiles && {
+                transformFiles: options.transformFiles
+            },
+            ...void 0 !== options.transform && {
+                transform: options.transform
+            },
+            ...void 0 !== options.virtualEntries && {
+                virtualEntries: options.virtualEntries
+            }
+        };
         return merged;
     }
     static create(options = {}) {
@@ -2280,40 +2403,62 @@ const TsDocLintPlugin = (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;
+        const apiModelConfig = "object" == typeof options.apiModel ? options.apiModel : {};
+        const tsdocConfig = apiModelConfig.tsdoc;
+        const lintConfig = tsdocConfig?.lint;
+        const lintEnabled = false !== options.apiModel && false !== lintConfig;
+        if (lintEnabled) {
+            const { lint: _lint, ...tsdocWithoutLint } = tsdocConfig ?? {};
+            const lintOptions = {
+                ...tsdocConfig && Object.keys(tsdocWithoutLint).length > 0 && {
+                    tsdoc: tsdocWithoutLint
+                },
+                ..."object" == typeof lintConfig ? lintConfig : {}
+            };
             plugins.push(TsDocLintPlugin(lintOptions));
         }
-        if (!options.entry) plugins.push(AutoEntryPlugin({
+        if (!options.entry) plugins.push(AutoEntryPlugin(null != options.exportsAsIndexes ? {
             exportsAsIndexes: options.exportsAsIndexes
-        }));
+        } : void 0));
         const userTransform = options.transform;
         const transformFn = userTransform ? (pkg)=>userTransform({
                 target,
                 pkg
             }) : void 0;
+        const libraryFormat = options.format ?? "esm";
         plugins.push(PackageJsonTransformPlugin({
             forcePrivate: "dev" === target,
             bundle: true,
             target,
-            transform: transformFn
+            format: libraryFormat,
+            ...transformFn && {
+                transform: transformFn
+            }
         }));
         plugins.push(FilesArrayPlugin({
             target,
-            transformFiles: options.transformFiles
+            ...options.transformFiles && {
+                transformFiles: options.transformFiles
+            }
         }));
         if (options.plugins) plugins.push(...options.plugins);
         const outputDir = `dist/${target}`;
         const entry = options.entry;
         const apiModelForTarget = "npm" === target ? options.apiModel : void 0;
         plugins.push(DtsPlugin({
-            tsconfigPath: options.tsconfigPath,
+            ...options.tsconfigPath && {
+                tsconfigPath: options.tsconfigPath
+            },
             abortOnError: true,
             bundle: true,
-            bundledPackages: options.dtsBundledPackages,
+            ...options.dtsBundledPackages && {
+                bundledPackages: options.dtsBundledPackages
+            },
             buildTarget: target,
-            apiModel: apiModelForTarget
+            format: libraryFormat,
+            ...void 0 !== apiModelForTarget && {
+                apiModel: apiModelForTarget
+            }
         }));
         const lib = {
             id: target,
@@ -2329,29 +2474,97 @@ const TsDocLintPlugin = (options = {})=>{
                 copy: {
                     patterns: options.copyPatterns
                 },
-                externals: options.externals && options.externals.length > 0 ? options.externals : void 0
+                ...options.externals && options.externals.length > 0 && {
+                    externals: options.externals
+                }
             },
-            format: "esm",
+            format: libraryFormat,
             experiments: {
-                advancedEsm: true
+                advancedEsm: "esm" === libraryFormat
             },
             bundle: true,
             plugins,
             source: {
-                tsconfigPath: options.tsconfigPath,
-                entry,
+                ...options.tsconfigPath && {
+                    tsconfigPath: options.tsconfigPath
+                },
+                ...entry && {
+                    entry
+                },
                 define: {
                     "process.env.__PACKAGE_VERSION__": JSON.stringify(VERSION),
                     ...options.define
                 }
             }
         };
+        const hasRegularEntries = void 0 !== options.entry || NodeLibraryBuilder.packageHasExports();
+        const virtualEntries = options.virtualEntries ?? {};
+        const hasVirtualEntries = Object.keys(virtualEntries).length > 0;
+        if (!hasRegularEntries && !hasVirtualEntries) throw new Error("No entry points configured. Provide package.json exports, explicit entry option, or virtualEntries.");
+        const libConfigs = [];
+        if (hasRegularEntries) libConfigs.push(lib);
+        if (hasVirtualEntries) {
+            const virtualByFormat = new Map();
+            for (const [outputName, config] of Object.entries(virtualEntries)){
+                const entryFormat = config.format ?? libraryFormat;
+                if (!virtualByFormat.has(entryFormat)) virtualByFormat.set(entryFormat, new Map());
+                const entryName = outputName.replace(/\.(c|m)?js$/, "");
+                const formatMap = virtualByFormat.get(entryFormat);
+                if (formatMap) formatMap.set(entryName, config.source);
+            }
+            for (const [format, entries] of virtualByFormat){
+                const virtualEntryNames = new Set(entries.keys());
+                const entryMap = Object.fromEntries(entries);
+                const virtualLib = {
+                    id: `${target}-virtual-${format}`,
+                    format,
+                    bundle: true,
+                    output: {
+                        target: "node",
+                        cleanDistPath: false,
+                        sourceMap: false,
+                        distPath: {
+                            root: outputDir
+                        },
+                        ...options.externals && options.externals.length > 0 && {
+                            externals: options.externals
+                        }
+                    },
+                    source: {
+                        entry: entryMap
+                    },
+                    plugins: [
+                        VirtualEntryPlugin({
+                            virtualEntryNames
+                        }),
+                        FilesArrayPlugin({
+                            target
+                        })
+                    ]
+                };
+                libConfigs.push(virtualLib);
+            }
+            if (hasRegularEntries) {
+                const allVirtualEntryNames = new Set();
+                for (const outputName of Object.keys(virtualEntries)){
+                    const entryName = outputName.replace(/\.(c|m)?js$/, "");
+                    allVirtualEntryNames.add(entryName);
+                }
+                plugins.push({
+                    name: "virtual-entry-names-exposer",
+                    setup (api) {
+                        api.expose("virtual-entry-names", allVirtualEntryNames);
+                    }
+                });
+                lib.plugins = plugins;
+            }
+        }
         return defineConfig({
-            lib: [
-                lib
-            ],
-            source: {
-                tsconfigPath: options.tsconfigPath
+            lib: libConfigs,
+            ...options.tsconfigPath && {
+                source: {
+                    tsconfigPath: options.tsconfigPath
+                }
             },
             performance: {
                 buildCache: {
@@ -2360,5 +2573,15 @@ const TsDocLintPlugin = (options = {})=>{
             }
         });
     }
+    static packageHasExports() {
+        try {
+            const packageJsonPath = join(process.cwd(), "package.json");
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            const { exports } = packageJson;
+            return null != exports && "object" == typeof exports && Object.keys(exports).length > 0;
+        } catch  {
+            return false;
+        }
+    }
 }
-export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin, TsconfigResolver, TsconfigResolverError, extractEntriesFromPackageJson };
+export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin, TsconfigResolver, TsconfigResolverError, VirtualEntryPlugin, extractEntriesFromPackageJson };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/rslib-builder",
-	"version": "0.8.1",
+	"version": "0.10.0",
 	"private": false,
 	"description": "RSlib-based build system for Node.js libraries with automatic package.json transformation, TypeScript declaration bundling, and multi-target support",
 	"keywords": [
@@ -50,11 +50,11 @@
 		"deep-equal": "^2.2.3",
 		"eslint": "^9.39.2",
 		"eslint-plugin-tsdoc": "^0.5.0",
-		"glob": "^13.0.0",
+		"glob": "^13.0.1",
 		"picocolors": "^1.1.1",
 		"sort-package-json": "^3.6.1",
 		"tmp": "^0.2.5",
-		"workspace-tools": "^0.40.4",
+		"workspace-tools": "^0.41.0",
 		"yaml": "^2.8.2"
 	},
 	"peerDependencies": {

package/tsconfig/ecma/lib.json

@@ -13,6 +13,7 @@
 		"incremental": true,
 		"isolatedDeclarations": false,
 		"isolatedModules": true,
+		"exactOptionalPropertyTypes": true,
 		"jsx": "preserve",
 		"lib": ["esnext"],
 		"module": "nodenext",