@module-federation/dts-plugin 2.0.1 → 2.1.0

package/dist/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @module-federation/dts-plugin
 
+## 2.1.0
+
+### Patch Changes
+
+- 6235711: Replace the Koa-based dev types server with a native Node HTTP server to reduce dependencies and keep type generation behavior unchanged.
+- 5954fe7: Fix fork-dev-worker crashes in dts-plugin when consumeTypes is disabled
+- Updated dependencies [918294f]
+- Updated dependencies [24bf84d]
+- Updated dependencies [918294f]
+- Updated dependencies [918294f]
+  - @module-federation/error-codes@2.1.0
+  - @module-federation/managers@2.1.0
+  - @module-federation/sdk@2.1.0
+  - @module-federation/third-party-dts-extractor@2.1.0
+
 ## 2.0.1
 
 ### Patch Changes

package/dist/DtsWorker-Dtem3-FM.d.ts

@@ -0,0 +1,166 @@
+import { moduleFederationPlugin } from "@module-federation/sdk";
+import ts from "typescript";
+import { ChildProcess } from "child_process";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region src/core/interfaces/RemoteOptions.d.ts
+interface RemoteOptions extends moduleFederationPlugin.DtsRemoteOptions {
+  moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+  context?: string;
+  implementation?: string;
+  hostRemoteTypesFolder?: string;
+  outputDir?: string;
+}
+//#endregion
+//#region src/core/interfaces/TsConfigJson.d.ts
+interface TsConfigJson {
+  extends?: string;
+  compilerOptions?: ts.CompilerOptions;
+  exclude?: string[];
+  include?: string[];
+  files?: string[];
+}
+//#endregion
+//#region src/core/configurations/remotePlugin.d.ts
+declare const retrieveRemoteConfig: (options: RemoteOptions) => {
+  tsConfig: TsConfigJson;
+  mapComponentsToExpose: Record<string, string>;
+  remoteOptions: Required<RemoteOptions>;
+};
+//#endregion
+//#region src/core/interfaces/HostOptions.d.ts
+interface HostOptions extends moduleFederationPlugin.DtsHostOptions {
+  moduleFederationConfig: moduleFederationPlugin.ModuleFederationPluginOptions;
+  context?: string;
+  implementation?: string;
+  runtimePkgs?: string[];
+}
+interface RemoteInfo {
+  name: string;
+  url: string;
+  alias: string;
+  zipUrl?: string;
+  apiTypeUrl?: string;
+}
+//#endregion
+//#region src/core/interfaces/DTSManagerOptions.d.ts
+interface DTSManagerOptions {
+  remote?: RemoteOptions;
+  host?: HostOptions;
+  extraOptions?: Record<string, any>;
+  displayErrorInTerminal?: moduleFederationPlugin.PluginDtsOptions['displayErrorInTerminal'];
+}
+//#endregion
+//#region src/server/constant.d.ts
+declare const enum UpdateMode {
+  POSITIVE = "POSITIVE",
+  PASSIVE = "PASSIVE"
+}
+//#endregion
+//#region src/core/lib/DTSManager.d.ts
+interface UpdateTypesOptions {
+  updateMode: UpdateMode;
+  remoteName?: string;
+  remoteTarPath?: string;
+  remoteInfo?: RemoteInfo;
+  once?: boolean;
+}
+declare class DTSManager {
+  options: DTSManagerOptions;
+  runtimePkgs: string[];
+  remoteAliasMap: Record<string, Required<RemoteInfo>>;
+  loadedRemoteAPIAlias: Set<string>;
+  extraOptions: Record<string, any>;
+  updatedRemoteInfos: Record<string, Required<RemoteInfo>>;
+  constructor(options: DTSManagerOptions);
+  generateAPITypes(mapComponentsToExpose: Record<string, string>): string;
+  extractRemoteTypes(options: ReturnType<typeof retrieveRemoteConfig>): Promise<void>;
+  generateTypes(): Promise<void>;
+  requestRemoteManifest(remoteInfo: RemoteInfo, hostOptions: Required<HostOptions>): Promise<Required<RemoteInfo>>;
+  consumeTargetRemotes(hostOptions: Required<HostOptions>, remoteInfo: Required<RemoteInfo>): Promise<[string, string]>;
+  downloadAPITypes(remoteInfo: Required<RemoteInfo>, destinationPath: string, hostOptions: Required<HostOptions>): Promise<boolean>;
+  consumeAPITypes(hostOptions: Required<HostOptions>): void;
+  consumeArchiveTypes(options: HostOptions): Promise<{
+    hostOptions: Required<HostOptions>;
+    downloadPromisesResult: PromiseSettledResult<[string, string]>[];
+  }>;
+  consumeTypes(): Promise<void>;
+  updateTypes(options: UpdateTypesOptions): Promise<void>;
+}
+//#endregion
+//#region src/core/rpc/expose-rpc.d.ts
+declare function exposeRpc(fn: (...args: any[]) => any): void;
+//#endregion
+//#region src/core/rpc/types.d.ts
+declare enum RpcGMCallTypes {
+  CALL = "mf_call",
+  RESOLVE = "mf_resolve",
+  REJECT = "mf_reject",
+  EXIT = "mf_exit"
+}
+interface RpcCallMessage {
+  type: RpcGMCallTypes.CALL;
+  id: string;
+  args: unknown[];
+}
+interface RpcResolveMessage {
+  type: RpcGMCallTypes.RESOLVE;
+  id: string;
+  value: unknown;
+}
+interface RpcRejectMessage {
+  type: RpcGMCallTypes.REJECT;
+  id: string;
+  error: unknown;
+}
+interface RpcExitMessage {
+  type: RpcGMCallTypes.EXIT;
+  id: string;
+}
+type RpcMessage = RpcCallMessage | RpcResolveMessage | RpcRejectMessage | RpcExitMessage;
+type RpcMethod = (...args: any[]) => any;
+type RpcRemoteMethod<T extends RpcMethod> = T extends ((...args: infer A) => infer R) ? R extends Promise<any> ? (...args: A) => R : (...args: A) => Promise<R> : (...args: unknown[]) => Promise<unknown>;
+//#endregion
+//#region src/core/rpc/wrap-rpc.d.ts
+interface WrapRpcOptions {
+  id: string;
+  once?: boolean;
+}
+declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
+//#endregion
+//#region src/core/rpc/rpc-worker.d.ts
+interface RpcWorkerBase {
+  connect(...args: unknown[]): any;
+  terminate(): void;
+  readonly connected: boolean;
+  readonly id: string;
+  readonly process: ChildProcess | undefined;
+}
+type RpcWorker<T extends RpcMethod = RpcMethod> = RpcWorkerBase & RpcRemoteMethod<T>;
+declare function createRpcWorker<T extends RpcMethod>(modulePath: string, data: unknown, memoryLimit?: number, once?: boolean): RpcWorker<T>;
+declare function getRpcWorkerData(): unknown;
+//#endregion
+//#region src/core/rpc/rpc-error.d.ts
+declare class RpcExitError extends Error {
+  readonly code?: string | number | null;
+  readonly signal?: string | null;
+  constructor(message: string, code?: string | number | null, signal?: string | null);
+}
+declare namespace index_d_exports {
+  export { RpcCallMessage, RpcExitError, RpcGMCallTypes, RpcMessage, RpcMethod, RpcRejectMessage, RpcRemoteMethod, RpcResolveMessage, RpcWorker, createRpcWorker, exposeRpc, getRpcWorkerData, wrapRpc };
+}
+//#endregion
+//#region src/core/lib/DtsWorker.d.ts
+type DtsWorkerOptions = DTSManagerOptions;
+declare class DtsWorker {
+  rpcWorker: RpcWorker<RpcMethod>;
+  private _options;
+  private _res;
+  constructor(options: DtsWorkerOptions);
+  removeUnSerializationOptions(): void;
+  get controlledPromise(): ReturnType<DTSManager['generateTypes']>;
+  exit(): void;
+}
+//#endregion
+export { DTSManagerOptions as a, retrieveRemoteConfig as c, DTSManager as i, TsConfigJson as l, DtsWorkerOptions as n, HostOptions as o, index_d_exports as r, RemoteInfo as s, DtsWorker as t, RemoteOptions as u };

package/dist/constant-BwEkyidO.d.ts

@@ -0,0 +1,42 @@
+import { a as DTSManagerOptions, i as DTSManager, l as TsConfigJson, o as HostOptions, s as RemoteInfo, u as RemoteOptions } from "./DtsWorker-Dtem3-FM.js";
+import { moduleFederationPlugin } from "@module-federation/sdk";
+
+//#region src/core/configurations/hostPlugin.d.ts
+declare const retrieveHostConfig: (options: HostOptions) => {
+  hostOptions: Required<HostOptions>;
+  mapRemotesToDownload: Record<string, RemoteInfo>;
+};
+//#endregion
+//#region src/core/lib/utils.d.ts
+declare function getDTSManagerConstructor(implementation?: string): typeof DTSManager;
+declare const validateOptions: (options: HostOptions) => void;
+declare function retrieveTypesAssetsInfo(options: RemoteOptions): {
+  apiTypesPath: string;
+  zipTypesPath: string;
+  zipName: string;
+  apiFileName: string;
+};
+declare const isTSProject: (dtsOptions: moduleFederationPlugin.ModuleFederationPluginOptions["dts"], context?: string) => boolean;
+//#endregion
+//#region src/core/lib/typeScriptCompiler.d.ts
+declare const retrieveMfTypesPath: (tsConfig: TsConfigJson, remoteOptions: Required<RemoteOptions>) => string;
+declare const retrieveOriginalOutDir: (tsConfig: TsConfigJson, remoteOptions: Required<RemoteOptions>) => string;
+//#endregion
+//#region src/core/lib/archiveHandler.d.ts
+declare const retrieveTypesZipPath: (mfTypesPath: string, remoteOptions: Required<RemoteOptions>) => string;
+//#endregion
+//#region src/core/lib/generateTypes.d.ts
+declare function generateTypes(options: DTSManagerOptions): Promise<void>;
+//#endregion
+//#region src/core/lib/generateTypesInChildProcess.d.ts
+declare function generateTypesInChildProcess(options: DTSManagerOptions): Promise<void>;
+//#endregion
+//#region src/core/lib/consumeTypes.d.ts
+declare function consumeTypes(options: DTSManagerOptions): Promise<void>;
+//#endregion
+//#region src/core/constant.d.ts
+declare const REMOTE_ALIAS_IDENTIFIER = "REMOTE_ALIAS_IDENTIFIER";
+declare const REMOTE_API_TYPES_FILE_NAME = "apis.d.ts";
+declare const HOST_API_TYPES_FILE_NAME = "index.d.ts";
+//#endregion
+export { generateTypesInChildProcess as a, retrieveMfTypesPath as c, isTSProject as d, retrieveTypesAssetsInfo as f, consumeTypes as i, retrieveOriginalOutDir as l, retrieveHostConfig as m, REMOTE_ALIAS_IDENTIFIER as n, generateTypes as o, validateOptions as p, REMOTE_API_TYPES_FILE_NAME as r, retrieveTypesZipPath as s, HOST_API_TYPES_FILE_NAME as t, getDTSManagerConstructor as u };

package/dist/consumeTypes-AD2ig87l.js

@@ -0,0 +1,237 @@
+const require_Action = require('./Action-CzhPMw2i.js');
+const require_expose_rpc = require('./expose-rpc-BLAH20uj.js');
+let path = require("path");
+path = require_Action.__toESM(path);
+let crypto = require("crypto");
+let child_process = require("child_process");
+child_process = require_Action.__toESM(child_process);
+let process$1 = require("process");
+process$1 = require_Action.__toESM(process$1);
+
+//#region src/core/rpc/rpc-error.ts
+var RpcExitError = class extends Error {
+	constructor(message, code, signal) {
+		super(message);
+		this.code = code;
+		this.signal = signal;
+		this.name = "RpcExitError";
+	}
+};
+
+//#endregion
+//#region src/core/rpc/wrap-rpc.ts
+function createControlledPromise() {
+	let resolve = () => void 0;
+	let reject = () => void 0;
+	return {
+		promise: new Promise((aResolve, aReject) => {
+			resolve = aResolve;
+			reject = aReject;
+		}),
+		resolve,
+		reject
+	};
+}
+function wrapRpc(childProcess, options) {
+	return (async (...args) => {
+		if (!childProcess.send) throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+		else if (!childProcess.connected) throw new Error(`Process ${childProcess.pid} doesn't have open IPC channels`);
+		const { id, once } = options;
+		const { promise: resultPromise, resolve: resolveResult, reject: rejectResult } = createControlledPromise();
+		const { promise: sendPromise, resolve: resolveSend, reject: rejectSend } = createControlledPromise();
+		const handleMessage = (message) => {
+			if (message?.id === id) {
+				if (message.type === require_expose_rpc.RpcGMCallTypes.RESOLVE) resolveResult(message.value);
+				else if (message.type === require_expose_rpc.RpcGMCallTypes.REJECT) rejectResult(message.error);
+			}
+			if (once && childProcess?.kill) childProcess.kill("SIGTERM");
+		};
+		const handleClose = (code, signal) => {
+			rejectResult(new RpcExitError(code ? `Process ${childProcess.pid} exited with code ${code}${signal ? ` [${signal}]` : ""}` : `Process ${childProcess.pid} exited${signal ? ` [${signal}]` : ""}`, code, signal));
+			removeHandlers();
+		};
+		const removeHandlers = () => {
+			childProcess.off("message", handleMessage);
+			childProcess.off("close", handleClose);
+		};
+		if (once) childProcess.once("message", handleMessage);
+		else childProcess.on("message", handleMessage);
+		childProcess.on("close", handleClose);
+		childProcess.send({
+			type: require_expose_rpc.RpcGMCallTypes.CALL,
+			id,
+			args
+		}, (error) => {
+			if (error) {
+				rejectSend(error);
+				removeHandlers();
+			} else resolveSend(void 0);
+		});
+		return sendPromise.then(() => resultPromise);
+	});
+}
+
+//#endregion
+//#region src/core/rpc/rpc-worker.ts
+const FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
+function createRpcWorker(modulePath, data, memoryLimit, once) {
+	const options = {
+		env: {
+			...process$1.env,
+			[FEDERATION_WORKER_DATA_ENV_KEY]: JSON.stringify(data || {})
+		},
+		stdio: [
+			"inherit",
+			"inherit",
+			"inherit",
+			"ipc"
+		],
+		serialization: "advanced"
+	};
+	if (memoryLimit) options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+	let childProcess, remoteMethod;
+	const id = (0, crypto.randomUUID)();
+	return {
+		connect(...args) {
+			if (childProcess && !childProcess.connected) {
+				childProcess.send({
+					type: require_expose_rpc.RpcGMCallTypes.EXIT,
+					id
+				});
+				childProcess = void 0;
+				remoteMethod = void 0;
+			}
+			if (!childProcess?.connected) {
+				childProcess = child_process.fork(modulePath, options);
+				remoteMethod = wrapRpc(childProcess, {
+					id,
+					once
+				});
+			}
+			if (!remoteMethod) return Promise.reject(/* @__PURE__ */ new Error("Worker is not connected - cannot perform RPC."));
+			return remoteMethod(...args);
+		},
+		terminate() {
+			try {
+				if (childProcess.connected) childProcess.send({
+					type: require_expose_rpc.RpcGMCallTypes.EXIT,
+					id
+				}, (err) => {
+					if (err) console.error("Error sending message:", err);
+				});
+			} catch (error) {
+				if (error.code === "EPIPE") console.error("Pipe closed before message could be sent:", error);
+				else console.error("Unexpected error:", error);
+			}
+			childProcess = void 0;
+			remoteMethod = void 0;
+		},
+		get connected() {
+			return Boolean(childProcess?.connected);
+		},
+		get process() {
+			return childProcess;
+		},
+		get id() {
+			return id;
+		}
+	};
+}
+function getRpcWorkerData() {
+	return JSON.parse(process$1.env[FEDERATION_WORKER_DATA_ENV_KEY] || "{}");
+}
+
+//#endregion
+//#region src/core/rpc/index.ts
+var rpc_exports = /* @__PURE__ */ require_Action.__exportAll({
+	RpcExitError: () => RpcExitError,
+	RpcGMCallTypes: () => require_expose_rpc.RpcGMCallTypes,
+	createRpcWorker: () => createRpcWorker,
+	exposeRpc: () => require_expose_rpc.exposeRpc,
+	getRpcWorkerData: () => getRpcWorkerData,
+	wrapRpc: () => wrapRpc
+});
+
+//#endregion
+//#region src/core/lib/DtsWorker.ts
+var DtsWorker = class {
+	constructor(options) {
+		this._options = require_expose_rpc.cloneDeepOptions(options);
+		this.removeUnSerializationOptions();
+		this.rpcWorker = createRpcWorker(path.default.resolve(__dirname, "./fork-generate-dts.js"), {}, void 0, true);
+		this._res = this.rpcWorker.connect(this._options);
+	}
+	removeUnSerializationOptions() {
+		if (this._options.remote?.moduleFederationConfig?.manifest) delete this._options.remote?.moduleFederationConfig?.manifest;
+		if (this._options.host?.moduleFederationConfig?.manifest) delete this._options.host?.moduleFederationConfig?.manifest;
+	}
+	get controlledPromise() {
+		const ensureChildProcessExit = () => {
+			try {
+				const pid = this.rpcWorker.process?.pid;
+				const rootPid = process.pid;
+				if (pid && rootPid !== pid) process.kill(pid, 0);
+			} catch (error) {
+				if (require_expose_rpc.isDebugMode()) console.error(error);
+			}
+		};
+		return Promise.resolve(this._res).then(() => {
+			this.exit();
+			ensureChildProcessExit();
+		}).catch((err) => {
+			if (require_expose_rpc.isDebugMode()) console.error(err);
+			ensureChildProcessExit();
+		});
+	}
+	exit() {
+		try {
+			this.rpcWorker?.terminate();
+		} catch (err) {
+			if (require_expose_rpc.isDebugMode()) console.error(err);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/lib/generateTypesInChildProcess.ts
+async function generateTypesInChildProcess(options) {
+	return new DtsWorker(options).controlledPromise;
+}
+
+//#endregion
+//#region src/core/lib/consumeTypes.ts
+async function consumeTypes(options) {
+	await new (require_expose_rpc.getDTSManagerConstructor(options.host?.implementation))(options).consumeTypes();
+}
+
+//#endregion
+Object.defineProperty(exports, 'DtsWorker', {
+  enumerable: true,
+  get: function () {
+    return DtsWorker;
+  }
+});
+Object.defineProperty(exports, 'consumeTypes', {
+  enumerable: true,
+  get: function () {
+    return consumeTypes;
+  }
+});
+Object.defineProperty(exports, 'createRpcWorker', {
+  enumerable: true,
+  get: function () {
+    return createRpcWorker;
+  }
+});
+Object.defineProperty(exports, 'generateTypesInChildProcess', {
+  enumerable: true,
+  get: function () {
+    return generateTypesInChildProcess;
+  }
+});
+Object.defineProperty(exports, 'rpc_exports', {
+  enumerable: true,
+  get: function () {
+    return rpc_exports;
+  }
+});

package/dist/core.d.ts

@@ -1,68 +1,3 @@
-import { T as TsConfigJson } from './DTSManager-b15Gfat3.js';
-export { D as DTSManager, r as retrieveRemoteConfig } from './DTSManager-b15Gfat3.js';
-import { H as HostOptions, R as RemoteInfo, a as RemoteOptions, D as DTSManagerOptions } from './DTSManagerOptions-QVchWb0x.js';
-export { g as getDTSManagerConstructor, i as isTSProject, r as retrieveTypesAssetsInfo, v as validateOptions } from './utils-C4sQemLR.js';
-import { R as RpcRemoteMethod, a as RpcCallMessage, b as RpcGMCallTypes, c as RpcMessage, d as RpcMethod, e as RpcRejectMessage, f as RpcResolveMessage, g as RpcWorker, h as createRpcWorker, i as getRpcWorkerData } from './DtsWorker-BrHsGz8C.js';
-export { D as DtsWorker } from './DtsWorker-BrHsGz8C.js';
-import { ChildProcess } from 'child_process';
-import 'typescript';
-import '@module-federation/sdk';
-
-declare const retrieveHostConfig: (options: HostOptions) => {
-    hostOptions: Required<HostOptions>;
-    mapRemotesToDownload: Record<string, RemoteInfo>;
-};
-
-declare const retrieveMfTypesPath: (tsConfig: TsConfigJson, remoteOptions: Required<RemoteOptions>) => string;
-declare const retrieveOriginalOutDir: (tsConfig: TsConfigJson, remoteOptions: Required<RemoteOptions>) => string;
-
-declare const retrieveTypesZipPath: (mfTypesPath: string, remoteOptions: Required<RemoteOptions>) => string;
-
-declare function generateTypes(options: DTSManagerOptions): Promise<void>;
-
-declare function generateTypesInChildProcess(options: DTSManagerOptions): Promise<void>;
-
-declare function exposeRpc(fn: (...args: any[]) => any): void;
-
-interface WrapRpcOptions {
-    id: string;
-    once?: boolean;
-}
-declare function wrapRpc<T extends (...args: any[]) => any>(childProcess: ChildProcess, options: WrapRpcOptions): RpcRemoteMethod<T>;
-
-declare class RpcExitError extends Error {
-    readonly code?: string | number | null;
-    readonly signal?: string | null;
-    constructor(message: string, code?: string | number | null, signal?: string | null);
-}
-
-/**
- * forked from https://github.com/TypeStrong/fork-ts-checker-webpack-plugin
- * license at https://github.com/TypeStrong/fork-ts-checker-webpack-plugin/blob/main/LICENSE
- */
-
-declare const index_RpcCallMessage: typeof RpcCallMessage;
-type index_RpcExitError = RpcExitError;
-declare const index_RpcExitError: typeof RpcExitError;
-declare const index_RpcGMCallTypes: typeof RpcGMCallTypes;
-declare const index_RpcMessage: typeof RpcMessage;
-declare const index_RpcMethod: typeof RpcMethod;
-declare const index_RpcRejectMessage: typeof RpcRejectMessage;
-declare const index_RpcRemoteMethod: typeof RpcRemoteMethod;
-declare const index_RpcResolveMessage: typeof RpcResolveMessage;
-declare const index_RpcWorker: typeof RpcWorker;
-declare const index_createRpcWorker: typeof createRpcWorker;
-declare const index_exposeRpc: typeof exposeRpc;
-declare const index_getRpcWorkerData: typeof getRpcWorkerData;
-declare const index_wrapRpc: typeof wrapRpc;
-declare namespace index {
-  export { index_RpcCallMessage as RpcCallMessage, index_RpcExitError as RpcExitError, index_RpcGMCallTypes as RpcGMCallTypes, index_RpcMessage as RpcMessage, index_RpcMethod as RpcMethod, index_RpcRejectMessage as RpcRejectMessage, index_RpcRemoteMethod as RpcRemoteMethod, index_RpcResolveMessage as RpcResolveMessage, index_RpcWorker as RpcWorker, index_createRpcWorker as createRpcWorker, index_exposeRpc as exposeRpc, index_getRpcWorkerData as getRpcWorkerData, index_wrapRpc as wrapRpc };
-}
-
-declare function consumeTypes(options: DTSManagerOptions): Promise<void>;
-
-declare const REMOTE_ALIAS_IDENTIFIER = "REMOTE_ALIAS_IDENTIFIER";
-declare const REMOTE_API_TYPES_FILE_NAME = "apis.d.ts";
-declare const HOST_API_TYPES_FILE_NAME = "index.d.ts";
-
-export { DTSManagerOptions, HOST_API_TYPES_FILE_NAME, HostOptions, REMOTE_ALIAS_IDENTIFIER, REMOTE_API_TYPES_FILE_NAME, RemoteOptions, consumeTypes, generateTypes, generateTypesInChildProcess, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveTypesZipPath, index as rpc };
+import { a as DTSManagerOptions, c as retrieveRemoteConfig, i as DTSManager, o as HostOptions, r as index_d_exports, t as DtsWorker, u as RemoteOptions } from "./DtsWorker-Dtem3-FM.js";
+import { a as generateTypesInChildProcess, c as retrieveMfTypesPath, d as isTSProject, f as retrieveTypesAssetsInfo, i as consumeTypes, l as retrieveOriginalOutDir, m as retrieveHostConfig, n as REMOTE_ALIAS_IDENTIFIER, o as generateTypes, p as validateOptions, r as REMOTE_API_TYPES_FILE_NAME, s as retrieveTypesZipPath, t as HOST_API_TYPES_FILE_NAME, u as getDTSManagerConstructor } from "./constant-BwEkyidO.js";
+export { DTSManager, type DTSManagerOptions, DtsWorker, HOST_API_TYPES_FILE_NAME, type HostOptions, REMOTE_ALIAS_IDENTIFIER, REMOTE_API_TYPES_FILE_NAME, type RemoteOptions, consumeTypes, generateTypes, generateTypesInChildProcess, getDTSManagerConstructor, isTSProject, retrieveHostConfig, retrieveMfTypesPath, retrieveOriginalOutDir, retrieveRemoteConfig, retrieveTypesAssetsInfo, retrieveTypesZipPath, index_d_exports as rpc, validateOptions };