@fulgurjs/federation 6.14.4 → 6.14.5

package/dist/dts-cache-worker.cjs

@@ -0,0 +1,684 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/dts-cache-worker.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_worker_threads = require("node:worker_threads");
+
+// src/dts-cache.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_module = require("node:module");
+var import_node_url = require("node:url");
+var import_node_zlib = require("node:zlib");
+
+// src/dts-shared.ts
+var TYPES_SCHEMA_VERSION = 1;
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function isSafeBundlePath(v) {
+  if (typeof v !== "string" || v.length === 0) return false;
+  if (v.startsWith("/") || v.startsWith("\\")) return false;
+  if (v.includes("\\")) return false;
+  if (v.split("/").includes("..")) return false;
+  if (/[\s\u0000-\u001f]/.test(v)) return false;
+  return true;
+}
+function parseDtsIndex(input) {
+  const issues = [];
+  if (!isPlainObject(input)) {
+    return { issues: [{ field: "$", message: "\u7C7B\u578B\u6E05\u5355\u5FC5\u987B\u662F JSON \u5BF9\u8C61", got: typeof input }] };
+  }
+  const raw = input;
+  if (raw.schemaVersion !== TYPES_SCHEMA_VERSION) {
+    return {
+      issues: [{
+        field: "schemaVersion",
+        message: `\u4E0D\u652F\u6301\u7684\u7C7B\u578B\u534F\u8BAE\u7248\u672C\uFF08\u5F53\u524D\u6D88\u8D39\u7AEF\u652F\u6301 ${TYPES_SCHEMA_VERSION}\uFF09`,
+        got: raw.schemaVersion
+      }],
+      unsupportedVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : void 0
+    };
+  }
+  if (typeof raw.revision !== "string" || !/^[0-9a-f]{8,64}$/.test(raw.revision)) {
+    issues.push({ field: "revision", message: "\u5FC5\u987B\u662F 8-64 \u4F4D\u5341\u516D\u8FDB\u5236\u5185\u5BB9\u6458\u8981", got: raw.revision });
+  }
+  if (!isPlainObject(raw.exposes) || Object.keys(raw.exposes).length === 0) {
+    issues.push({ field: "exposes", message: "\u5FC5\u987B\u662F\u975E\u7A7A\u5BF9\u8C61\uFF08\u66B4\u9732\u5165\u53E3 \u2192 \u58F0\u660E\u6587\u4EF6\u6620\u5C04\uFF09", got: typeof raw.exposes });
+  } else {
+    for (const [name, v] of Object.entries(raw.exposes)) {
+      if (!/^\.[\w./-]+$/.test(name)) {
+        issues.push({ field: `exposes["${name}"]`, message: '\u952E\u5FC5\u987B\u662F "./xxx" \u5F62\u6001\u7684 expose \u540D' });
+      }
+      if (!isPlainObject(v) || !isSafeBundlePath(v.declaration)) {
+        issues.push({ field: `exposes["${name}"].declaration`, message: "\u5FC5\u987B\u662F bundle \u5185\u5B89\u5168\u76F8\u5BF9\u8DEF\u5F84", got: v });
+      }
+    }
+  }
+  if (!isPlainObject(raw.files) || Object.keys(raw.files).length === 0) {
+    issues.push({ field: "files", message: "\u5FC5\u987B\u662F\u975E\u7A7A\u5BF9\u8C61\uFF08\u6587\u4EF6 \u2192 sha256\uFF09", got: typeof raw.files });
+  } else {
+    for (const [file, digest] of Object.entries(raw.files)) {
+      if (!isSafeBundlePath(file)) {
+        issues.push({ field: `files["${file}"]`, message: "\u4E0D\u5B89\u5168\u7684 bundle \u6587\u4EF6\u8DEF\u5F84\uFF08\u62D2\u7EDD\u8D8A\u754C\uFF09" });
+      }
+      if (typeof digest !== "string" || !/^[0-9a-f]{64}$/.test(digest)) {
+        issues.push({ field: `files["${file}"]`, message: "\u5FC5\u987B\u662F sha256 \u5341\u516D\u8FDB\u5236\u6458\u8981", got: digest });
+      }
+    }
+    if (isPlainObject(raw.exposes)) {
+      for (const [name, v] of Object.entries(raw.exposes)) {
+        if (isPlainObject(v) && typeof v.declaration === "string" && !Object.hasOwn(raw.files, v.declaration)) {
+          issues.push({ field: `exposes["${name}"].declaration`, message: `\u58F0\u660E\u6587\u4EF6\u672A\u5728 files \u4E2D\u767B\u8BB0\uFF08${v.declaration}\uFF09` });
+        }
+      }
+    }
+  }
+  if (raw.externals !== void 0) {
+    if (!Array.isArray(raw.externals) || raw.externals.some((e) => typeof e !== "string")) {
+      issues.push({ field: "externals", message: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u5916\u90E8\u7C7B\u578B\u4F9D\u8D56\u5305\u540D\uFF09", got: typeof raw.externals });
+    }
+  }
+  if (issues.length > 0) return { issues };
+  return {
+    index: {
+      schemaVersion: TYPES_SCHEMA_VERSION,
+      generator: typeof raw.generator === "string" ? raw.generator : "@fulgurjs/federation",
+      pluginVersion: typeof raw.pluginVersion === "string" ? raw.pluginVersion : "",
+      revision: raw.revision,
+      exposes: raw.exposes,
+      externals: Array.isArray(raw.externals) ? raw.externals : [],
+      files: raw.files
+    },
+    issues
+  };
+}
+var DTS_FILE_MAX_BYTES = 5 * 1024 * 1024;
+var DTS_TOTAL_MAX_BYTES = 64 * 1024 * 1024;
+var DTS_FILE_COUNT_MAX = 4e3;
+
+// src/dts-cache.ts
+var import_meta = {};
+var CACHE_FORMAT = 1;
+var PROCESS_START = Date.now() - process.uptime() * 1e3;
+var MAX_CACHE_BYTES = DTS_TOTAL_MAX_BYTES * 2;
+var hash = (value) => import_node_crypto.default.createHash("sha256").update(value).digest("hex");
+var sorted = (values) => [...values].sort();
+var temporary = (file) => import_node_path.default.basename(file).startsWith(".fulgurjs-types-tsconfig-");
+var stamp = (file) => {
+  const data = import_node_fs.default.readFileSync(file);
+  const stat = import_node_fs.default.statSync(file);
+  return { hash: hash(data), size: stat.size, mtime: stat.mtimeMs, ctime: stat.ctimeMs, ino: stat.ino };
+};
+var resolve = (from, request) => {
+  try {
+    return (0, import_node_module.createRequire)(from).resolve(request);
+  } catch {
+    return null;
+  }
+};
+function linkIdentity(file) {
+  try {
+    return import_node_fs.default.realpathSync(file);
+  } catch {
+    return `!missing:${import_node_fs.default.readlinkSync(file)}`;
+  }
+}
+function ownModule() {
+  return typeof __filename === "string" ? __filename : (0, import_node_url.fileURLToPath)(import_meta.url);
+}
+function settings(input) {
+  const env = Object.fromEntries(Object.entries(input.execution?.env ?? process.env).filter(([name]) => /^(NODE_ENV|NODE_OPTIONS|TS_NODE_|VUE_|VOLAR_)/.test(name)).sort(([a], [b]) => a < b ? -1 : 1));
+  return hash(JSON.stringify({
+    format: CACHE_FORMAT,
+    root: import_node_path.default.resolve(input.root),
+    exposes: input.exposes,
+    pluginVersion: input.pluginVersion,
+    ownModule: ownModule(),
+    dts: input.dts,
+    node: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    execArgv: input.execution?.execArgv ?? process.execArgv,
+    env
+  }));
+}
+function typesCachePath(root) {
+  return import_node_path.default.join(root, "node_modules/.cache/fulgurjs/types", `provider-${hash(import_node_path.default.resolve(root)).slice(0, 12)}.json.gz`);
+}
+function captureTypesInputs(input) {
+  const root = import_node_path.default.resolve(input.root);
+  const from = import_node_path.default.join(root, "package.json");
+  const tsFile = resolve(from, "typescript");
+  if (!tsFile) return null;
+  let ts;
+  try {
+    ts = (0, import_node_module.createRequire)(from)("typescript");
+  } catch {
+    return null;
+  }
+  const snapshot = { caseSensitive: ts.sys.useCaseSensitiveFileNames, directoryStats: {}, files: {}, probes: {}, fileQueries: {}, directories: [], links: {}, resolutions: [], runtimeTools: [] };
+  const queues = [];
+  const visited = /* @__PURE__ */ new Set();
+  const toolPackages = /* @__PURE__ */ new Set();
+  const toolRuntime = /* @__PURE__ */ new Set();
+  let unsupported = false;
+  const observeDirectory = (dir) => {
+    const absolute = import_node_path.default.resolve(dir);
+    if (Object.hasOwn(snapshot.directoryStats, absolute)) return;
+    try {
+      const stat = import_node_fs.default.statSync(absolute);
+      if (stat.isDirectory()) snapshot.directoryStats[absolute] = { mtime: stat.mtimeMs, ctime: stat.ctimeMs, ino: stat.ino };
+    } catch {
+    }
+  };
+  const entriesCache = /* @__PURE__ */ new Map();
+  const sourceCache = /* @__PURE__ */ new Map();
+  const entries2 = (dir) => {
+    const cached = entriesCache.get(dir);
+    if (cached) return cached;
+    let rows = [];
+    observeDirectory(dir);
+    observeDirectory(import_node_path.default.dirname(dir));
+    try {
+      rows = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+      snapshot.links[dir] = import_node_fs.default.realpathSync(dir);
+    } catch (e) {
+      if (!["ENOENT", "ENOTDIR"].includes(e.code ?? "")) throw e;
+    }
+    const result = new Map(rows.flatMap((row) => [[`e:${row.name}`, row], [`f:${row.name.toLowerCase()}`, row]]));
+    entriesCache.set(dir, result);
+    return result;
+  };
+  const fileExists = (file) => {
+    const absolute = import_node_path.default.resolve(file);
+    const dir = import_node_path.default.dirname(absolute);
+    const name = import_node_path.default.basename(absolute);
+    const query = snapshot.fileQueries[dir] ??= /* @__PURE__ */ Object.create(null);
+    if (Object.hasOwn(query, name)) return query[name];
+    const table = entries2(dir);
+    const entry = table.get(`e:${name}`) ?? (!snapshot.caseSensitive ? table.get(`f:${name.toLowerCase()}`) : void 0);
+    let exists = entry?.isFile() ?? false;
+    if (entry && entry.name !== name) {
+      try {
+        exists = import_node_fs.default.statSync(absolute).isFile();
+      } catch {
+        exists = false;
+      }
+    }
+    if (entry?.isSymbolicLink() && (exists || import_node_fs.default.existsSync(absolute))) {
+      snapshot.links[absolute] = linkIdentity(absolute);
+      try {
+        exists = import_node_fs.default.statSync(absolute).isFile();
+      } catch {
+        exists = false;
+      }
+    }
+    query[name] = exists;
+    return exists;
+  };
+  const directoryExists = (dir) => {
+    const absolute = import_node_path.default.resolve(dir);
+    const key = `d:${absolute}`;
+    if (Object.hasOwn(snapshot.probes, key)) return snapshot.probes[key];
+    observeDirectory(absolute);
+    observeDirectory(import_node_path.default.dirname(absolute));
+    const exists = ts.sys.directoryExists?.(absolute) ?? false;
+    snapshot.probes[key] = exists;
+    return exists;
+  };
+  const read = (file) => {
+    const absolute = import_node_path.default.resolve(file);
+    if (sourceCache.has(absolute)) return sourceCache.get(absolute);
+    if (!fileExists(absolute)) return void 0;
+    const before = import_node_fs.default.statSync(absolute);
+    const data = import_node_fs.default.readFileSync(absolute);
+    const after = import_node_fs.default.statSync(absolute);
+    if (before.ctimeMs !== after.ctimeMs || before.mtimeMs !== after.mtimeMs || before.size !== after.size || before.ino !== after.ino) throw new Error("\u8F93\u5165\u5728\u8BFB\u53D6\u8FC7\u7A0B\u4E2D\u53D8\u5316");
+    const real = import_node_fs.default.realpathSync(absolute);
+    snapshot.links[absolute] = real;
+    snapshot.files[absolute] = { hash: hash(data), size: after.size, mtime: after.mtimeMs, ctime: after.ctimeMs, ino: after.ino };
+    const text = data.toString("utf8");
+    sourceCache.set(absolute, text);
+    return text;
+  };
+  const requirePath = (file, request) => {
+    const resolved = resolve(file, request);
+    snapshot.resolutions.push({ from: file, request, resolved });
+    if (request.startsWith(".") || import_node_path.default.isAbsolute(request)) {
+      const base = import_node_path.default.resolve(import_node_path.default.dirname(file), request);
+      for (const candidate of [base, `${base}.js`, `${base}.json`, `${base}.node`, import_node_path.default.join(base, "package.json"), import_node_path.default.join(base, "index.js")]) fileExists(candidate);
+    } else if (resolved && import_node_path.default.isAbsolute(resolved)) {
+      const packageName = request.startsWith("@") ? request.split("/").slice(0, 2).join("/") : request.split("/")[0];
+      for (const directory of (0, import_node_module.createRequire)(file).resolve.paths(request) ?? []) {
+        const candidate = import_node_path.default.join(directory, packageName);
+        if (!directoryExists(candidate)) continue;
+        const actual = import_node_fs.default.realpathSync(candidate);
+        snapshot.links[candidate] = actual;
+        if (!(resolved === actual || resolved.startsWith(`${actual}${import_node_path.default.sep}`))) unsupported = true;
+        break;
+      }
+    }
+    return resolved;
+  };
+  const host = {
+    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    readFile: read,
+    fileExists: (file) => fileExists(file) || file.endsWith(".vue.ts") && fileExists(file.slice(0, -3)),
+    directoryExists,
+    realpath: (file) => {
+      const resolved = ts.sys.realpath?.(file) ?? file;
+      try {
+        snapshot.links[file] = import_node_fs.default.realpathSync(file);
+      } catch {
+      }
+      return resolved;
+    },
+    readDirectory: (dir, extensions, excludes, includes, depth) => {
+      observeDirectory(dir);
+      const result = sorted(ts.sys.readDirectory(dir, extensions, excludes, includes, depth).filter((file) => !temporary(file)));
+      snapshot.directories.push({ kind: "files", root: dir, extensions, excludes, includes, depth, result });
+      return result;
+    },
+    getDirectories: (dir) => {
+      observeDirectory(dir);
+      const result = sorted(ts.sys.getDirectories(dir));
+      snapshot.directories.push({ kind: "dirs", root: dir, result });
+      return result;
+    }
+  };
+  const add = (file) => {
+    if (fileExists(file) && !temporary(file)) queues.push(import_node_path.default.resolve(file));
+  };
+  const packageRoot = (file) => {
+    for (let dir = import_node_path.default.dirname(file); ; dir = import_node_path.default.dirname(dir)) {
+      if (fileExists(import_node_path.default.join(dir, "package.json"))) return dir;
+      if (import_node_path.default.dirname(dir) === dir) return null;
+    }
+  };
+  const walkCode = (dir, recurse, tools, inspect) => {
+    observeDirectory(dir);
+    const entries3 = import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => !["node_modules", ".git", ".svn", ".cache"].includes(e.name) && (e.isDirectory() ? recurse : /\.(?:[cm]?js|[cm]?tsx?|json|vue|node|wasm)$/.test(e.name)));
+    snapshot.directories.push({ kind: "entries", root: dir, recurse, result: sorted(entries3.map((e) => e.name)) });
+    for (const entry of entries3) {
+      const file = import_node_path.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (recurse) walkCode(file, true, tools, inspect);
+        continue;
+      }
+      if (!/\.(?:[cm]?js|[cm]?tsx?|json|vue|node|wasm)$/.test(entry.name)) continue;
+      const text = read(file);
+      if (tools && !/\.d\.[cm]?ts$/.test(entry.name)) toolRuntime.add(file);
+      if (text !== void 0 && /\.[cm]?js$/.test(file)) inspect?.(file, text);
+    }
+  };
+  const tool = (file) => {
+    if (!import_node_path.default.isAbsolute(file)) return;
+    const directory = packageRoot(file);
+    if (!directory || toolPackages.has(directory)) return;
+    toolPackages.add(directory);
+    walkCode(directory, true, true, (source, text) => {
+      for (const imported of ts.preProcessFile(text, true, true).importedFiles) {
+        const dependency = requirePath(source, imported.fileName);
+        if (dependency) tool(dependency);
+      }
+    });
+    const json = JSON.parse(read(import_node_path.default.join(directory, "package.json")) ?? "{}");
+    for (const name of Object.keys({ ...json.dependencies, ...json.peerDependencies })) {
+      const dependency = requirePath(import_node_path.default.join(directory, "package.json"), `${name}/package.json`) ?? requirePath(import_node_path.default.join(directory, "package.json"), name);
+      if (dependency) tool(dependency);
+    }
+  };
+  try {
+    requirePath(from, "typescript");
+    tool(tsFile);
+    for (const request of ["typescript/lib/tsc.js", "vue-tsc/package.json", "vue/compiler-sfc"]) {
+      const file = requirePath(from, request);
+      if (file) tool(file);
+    }
+    const ownFile = ownModule();
+    const ownDirectory = import_node_path.default.dirname(ownFile);
+    walkCode(ownDirectory, ownFile.endsWith(".ts"), true);
+    for (let dir = root; ; dir = import_node_path.default.dirname(dir)) {
+      for (const name of ["package.json", "package-lock.json", "pnpm-lock.yaml", "pnpm-workspace.yaml", "yarn.lock", "bun.lock", "bun.lockb"]) read(import_node_path.default.join(dir, name));
+      if (import_node_path.default.dirname(dir) === dir) break;
+    }
+    const config = ts.findConfigFile(root, fileExists, "tsconfig.json");
+    let options = {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler ?? ts.ModuleResolutionKind.NodeJs,
+      allowJs: true,
+      skipLibCheck: true
+    };
+    if (config) {
+      const raw = ts.readConfigFile(config, read);
+      if (raw.error) return null;
+      const parsed = ts.parseJsonConfigFileContent(
+        raw.config,
+        host,
+        import_node_path.default.dirname(config),
+        void 0,
+        void 0,
+        void 0,
+        [{ extension: ".vue", isMixedContent: true, scriptKind: ts.ScriptKind.Deferred }]
+      );
+      if (parsed.errors.some((d) => d.category === ts.DiagnosticCategory.Error)) return null;
+      options = parsed.options;
+      for (const file of parsed.fileNames) add(file);
+    }
+    const resolutionCache = ts.createModuleResolutionCache(root, (file) => ts.sys.useCaseSensitiveFileNames ? file : file.toLowerCase(), options);
+    const module2 = (name, containing) => {
+      for (const mode of [ts.ModuleKind.ESNext, ts.ModuleKind.CommonJS]) {
+        const result = ts.resolveModuleName(name, containing, options, host, resolutionCache, void 0, mode).resolvedModule;
+        if (result) {
+          let file = result.resolvedFileName;
+          if (file.endsWith(".vue.ts") && fileExists(file.slice(0, -3))) file = file.slice(0, -3);
+          add(file);
+        }
+      }
+      const bases = [];
+      if (name.startsWith(".")) bases.push(import_node_path.default.resolve(import_node_path.default.dirname(containing), name));
+      const base = options.baseUrl ?? (typeof options.pathsBasePath === "string" ? options.pathsBasePath : root);
+      for (const [pattern, targets] of Object.entries(options.paths ?? {})) {
+        const star = pattern.indexOf("*");
+        const match = star < 0 ? name === pattern : name.startsWith(pattern.slice(0, star)) && name.endsWith(pattern.slice(star + 1));
+        if (match) for (const target of targets) bases.push(import_node_path.default.resolve(base, target.replace("*", star < 0 ? "" : name.slice(star, name.length - (pattern.length - star - 1)))));
+      }
+      if (import_node_path.default.isAbsolute(name)) bases.push(name);
+      if (options.baseUrl) bases.push(import_node_path.default.resolve(options.baseUrl, name));
+      for (const target of bases) for (const candidate of [target, `${target}.vue`, `${target}.ts`, `${target}.tsx`, import_node_path.default.join(target, "index.vue"), import_node_path.default.join(target, "index.ts")]) add(candidate);
+    };
+    const typeReference = (name, containing) => {
+      for (const mode of [ts.ModuleKind.ESNext, ts.ModuleKind.CommonJS]) {
+        const resolved = ts.resolveTypeReferenceDirective(name, containing, options, host, void 0, void 0, mode).resolvedTypeReferenceDirective;
+        if (resolved?.resolvedFileName) add(resolved.resolvedFileName);
+      }
+    };
+    for (const entry of input.exposes) {
+      const file = import_node_path.default.resolve(root, entry.import.replace(/^\.?\//, ""));
+      if (fileExists(file)) add(file);
+      else module2(entry.import, from);
+    }
+    for (const name of ts.getAutomaticTypeDirectiveNames(options, host)) typeReference(name, config ?? from);
+    if (options.lib) for (const lib of options.lib) add(import_node_path.default.join(import_node_path.default.dirname(ts.getDefaultLibFilePath(options)), lib));
+    else if (!options.noLib) add(ts.getDefaultLibFilePath(options));
+    while (queues.length) {
+      const file = queues.pop();
+      if (visited.has(file)) continue;
+      visited.add(file);
+      let text = read(file);
+      if (text === void 0) continue;
+      if (file.endsWith(".vue")) {
+        const parser = (0, import_node_module.createRequire)(from)("vue/compiler-sfc");
+        const { descriptor } = parser.parse(text);
+        if (descriptor.template?.src || descriptor.template?.lang && descriptor.template.lang !== "html" || descriptor.styles.some((s) => s.module && s.src)) unsupported = true;
+        for (const script of [descriptor.script, descriptor.scriptSetup]) if (script?.src) module2(script.src, file);
+        text = [descriptor.script?.content, descriptor.scriptSetup?.content].filter(Boolean).join("\n");
+      }
+      if (!/\.(?:[cm]?[jt]sx?|vue)$/.test(file)) continue;
+      const info = ts.preProcessFile(text, true, true);
+      for (const imported of info.importedFiles) module2(imported.fileName, file);
+      if (text.includes("/**") && text.includes("import")) {
+        const source = ts.createSourceFile(
+          file,
+          text,
+          ts.ScriptTarget.Latest,
+          true,
+          /\.[jt]sx$/.test(file) ? ts.ScriptKind.TSX : /\.[cm]?js$/.test(file) ? ts.ScriptKind.JS : ts.ScriptKind.TS
+        );
+        const visit = (node) => {
+          if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal)) module2(node.argument.literal.text, file);
+          if (node.kind === ts.SyntaxKind.JSDocImportTag) {
+            const specifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(specifier)) module2(specifier.text, file);
+          }
+          ts.forEachChild(node, visit);
+          for (const doc of node.jsDoc ?? []) visit(doc);
+        };
+        visit(source);
+      }
+      for (const ref of info.referencedFiles) add(import_node_path.default.resolve(import_node_path.default.dirname(file), ref.fileName));
+      for (const ref of info.typeReferenceDirectives) typeReference(ref.fileName, file);
+      for (const ref of info.libReferenceDirectives ?? []) {
+        add(import_node_path.default.join(import_node_path.default.dirname(ts.getDefaultLibFilePath(options)), `lib.${ref.fileName.toLowerCase()}.d.ts`));
+        module2(`@typescript/lib-${ref.fileName.toLowerCase().replace(".", "/")}`, from);
+      }
+    }
+    for (const file of Object.keys(snapshot.files)) if (file.endsWith(".json")) {
+      const configText = ts.parseConfigFileTextToJson(file, import_node_fs.default.readFileSync(file, "utf8")).config;
+      if (configText?.vueCompilerOptions?.plugins?.length || configText?.vueCompilerOptions?.hooks?.length) unsupported = true;
+    }
+    snapshot.runtimeTools = [...toolRuntime];
+    return unsupported ? null : snapshot;
+  } catch {
+    return null;
+  }
+}
+function validateTypesInputs(snapshot, root, stable = false) {
+  try {
+    const checked = /* @__PURE__ */ new Map();
+    const checkedDirectories = /* @__PURE__ */ new Map();
+    for (const dir of Object.keys(snapshot.directoryStats ?? {})) {
+      const stat = import_node_fs.default.statSync(dir);
+      const now = { mtime: stat.mtimeMs, ctime: stat.ctimeMs, ino: stat.ino };
+      checkedDirectories.set(dir, now);
+    }
+    for (const [file, before] of Object.entries(snapshot.files)) {
+      const prior = import_node_fs.default.statSync(file);
+      const now = stamp(file);
+      if (prior.ctimeMs !== now.ctime || prior.mtimeMs !== now.mtime || prior.ino !== now.ino || prior.size !== now.size || now.hash !== before.hash || stable && (now.ctime !== before.ctime || now.mtime !== before.mtime || now.ino !== before.ino)) return `\u8F93\u5165\u6587\u4EF6\u53D8\u5316\uFF1A${import_node_path.default.relative(root, file)}`;
+      checked.set(file, now);
+    }
+    for (const [probe, expected] of Object.entries(snapshot.probes)) {
+      const file = probe.slice(2);
+      let found = false;
+      try {
+        const stat = import_node_fs.default.statSync(file);
+        found = probe.startsWith("f:") ? stat.isFile() : stat.isDirectory();
+      } catch {
+      }
+      if (found !== expected) return `\u8F93\u5165\u6210\u5458\u53D8\u5316\uFF1A${import_node_path.default.relative(root, file)}`;
+    }
+    for (const [dir, queries] of Object.entries(snapshot.fileQueries)) {
+      let rows = [];
+      try {
+        rows = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+      } catch (e) {
+        if (!["ENOENT", "ENOTDIR"].includes(e.code ?? "")) return "\u8F93\u5165\u76EE\u5F55\u4E0D\u53EF\u8BFB\u53D6";
+      }
+      const entries2 = new Map(rows.flatMap((row) => [[`e:${row.name}`, row], [`f:${row.name.toLowerCase()}`, row]]));
+      for (const [name, expected] of Object.entries(queries)) {
+        const row = entries2.get(`e:${name}`) ?? (!snapshot.caseSensitive ? entries2.get(`f:${name.toLowerCase()}`) : void 0);
+        let actual = row?.isFile() ?? false;
+        if (row && row.name !== name) {
+          try {
+            actual = import_node_fs.default.statSync(import_node_path.default.join(dir, name)).isFile();
+          } catch {
+            actual = false;
+          }
+        }
+        if (row?.isSymbolicLink()) {
+          try {
+            actual = import_node_fs.default.statSync(import_node_path.default.join(dir, name)).isFile();
+          } catch {
+            actual = false;
+          }
+        }
+        if (actual !== expected) return `\u4F9D\u8D56\u89E3\u6790\u5019\u9009\u53D8\u5316\uFF1A${import_node_path.default.relative(root, import_node_path.default.join(dir, name))}`;
+      }
+    }
+    for (const [file, expected] of Object.entries(snapshot.links)) if (linkIdentity(file) !== expected) return "\u4F9D\u8D56\u94FE\u63A5\u76EE\u6807\u53D8\u5316";
+    for (const query of snapshot.resolutions) if (resolve(query.from, query.request) !== query.resolved) return "\u5DE5\u5177\u4F9D\u8D56\u89E3\u6790\u53D8\u5316";
+    const tsPath = resolve(import_node_path.default.join(root, "package.json"), "typescript");
+    if (!tsPath) return "TypeScript\u5DE5\u5177\u4E0D\u53EF\u7528";
+    const ts = (0, import_node_module.createRequire)(import_node_path.default.join(root, "package.json"))("typescript");
+    for (const query of snapshot.directories) {
+      const result = query.kind === "files" ? ts.sys.readDirectory(query.root, query.extensions, query.excludes, query.includes, query.depth).filter((file) => !temporary(file)) : query.kind === "dirs" ? ts.sys.getDirectories(query.root) : import_node_fs.default.readdirSync(query.root, { withFileTypes: true }).filter((entry) => !["node_modules", ".git", ".svn", ".cache"].includes(entry.name) && (entry.isDirectory() ? query.recurse : /\.(?:[cm]?js|[cm]?tsx?|json|vue|node|wasm)$/.test(entry.name))).map((entry) => entry.name);
+      if (JSON.stringify(sorted(result)) !== JSON.stringify(query.result)) return `\u8F93\u5165\u76EE\u5F55\u6210\u5458\u53D8\u5316\uFF1A${import_node_path.default.relative(root, query.root)}`;
+    }
+    for (const [dir, before] of checkedDirectories) {
+      const stat = import_node_fs.default.statSync(dir);
+      if (stat.mtimeMs !== before.mtime || stat.ctimeMs !== before.ctime || stat.ino !== before.ino) {
+        for (const [name, expected] of Object.entries(snapshot.fileQueries[dir] ?? {})) {
+          let actual = false;
+          try {
+            actual = import_node_fs.default.statSync(import_node_path.default.join(dir, name)).isFile();
+          } catch {
+          }
+          if (actual !== expected) return `\u6821\u9A8C\u671F\u95F4\u89E3\u6790\u5019\u9009\u53D8\u5316\uFF1A${import_node_path.default.relative(root, import_node_path.default.join(dir, name))}`;
+        }
+        if (snapshot.directories.some((query) => query.root === dir)) return `\u6821\u9A8C\u671F\u95F4\u8F93\u5165\u76EE\u5F55\u53D8\u5316\uFF1A${import_node_path.default.relative(root, dir)}`;
+      }
+    }
+    for (const [file, before] of checked) {
+      const now = import_node_fs.default.statSync(file);
+      if (now.ctimeMs !== before.ctime || now.mtimeMs !== before.mtime || now.ino !== before.ino || now.size !== before.size) return `\u6821\u9A8C\u671F\u95F4\u8F93\u5165\u53D8\u5316\uFF1A${import_node_path.default.relative(root, file)}`;
+    }
+    return null;
+  } catch {
+    return "\u8F93\u5165\u4E0D\u53EF\u8BFB\u53D6\u6216\u5FEB\u7167\u65E0\u6548";
+  }
+}
+function runtimeIsStable(snapshot) {
+  return snapshot.runtimeTools.every((file) => (snapshot.files[file]?.ctime ?? Infinity) <= PROCESS_START);
+}
+function readTypesCache(input, verifyInputs = true) {
+  try {
+    const file = typesCachePath(input.root);
+    if (import_node_fs.default.statSync(file).size > MAX_CACHE_BYTES) return null;
+    const envelope = JSON.parse((0, import_node_zlib.gunzipSync)(import_node_fs.default.readFileSync(file), { maxOutputLength: MAX_CACHE_BYTES }).toString("utf8"));
+    const p = envelope.payload;
+    if (envelope.digest !== hash(JSON.stringify(p)) || p.format !== CACHE_FORMAT || p.key !== settings(input)) return null;
+    const rawIndex = JSON.parse(p.files["index.json"]);
+    const { revision, ...indexBody } = rawIndex;
+    if (revision !== hash(JSON.stringify(indexBody)).slice(0, 16)) return null;
+    const parsed = parseDtsIndex(rawIndex);
+    const index = parsed.index;
+    if (!index || index.pluginVersion !== input.pluginVersion || index.generator !== "@fulgurjs/federation" || !["typescript", "vue-tsc"].includes(p.tool) || Object.keys(index.files).length > DTS_FILE_COUNT_MAX) return null;
+    if (Object.keys(p.files).length !== Object.keys(index.files).length + 1) return null;
+    if (JSON.stringify(sorted(Object.keys(index.exposes))) !== JSON.stringify(sorted(input.exposes.map((e) => e.name)))) return null;
+    let bytes = 0;
+    for (const [name, digest] of Object.entries(index.files)) {
+      const text = p.files[name];
+      if (typeof text !== "string" || Buffer.byteLength(text) > DTS_FILE_MAX_BYTES || hash(text) !== digest) return null;
+      bytes += Buffer.byteLength(text);
+    }
+    if (bytes > DTS_TOTAL_MAX_BYTES || !runtimeIsStable(p.snapshot) || verifyInputs && validateTypesInputs(p.snapshot, input.root)) return null;
+    return { snapshot: p.snapshot, result: { ok: true, index, files: new Map(Object.entries(p.files)), tool: p.tool, fileCount: Object.keys(index.files).length, notices: [] } };
+  } catch {
+    return null;
+  }
+}
+function writeTypesCache(input, snapshot, result, temporaryId) {
+  if (!runtimeIsStable(snapshot)) return;
+  const file = typesCachePath(input.root);
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(file), { recursive: true });
+  const payload = { format: CACHE_FORMAT, key: settings(input), snapshot, files: Object.fromEntries(result.files), tool: result.tool };
+  const text = JSON.stringify({ digest: hash(JSON.stringify(payload)), payload });
+  if (Buffer.byteLength(text) > MAX_CACHE_BYTES) return;
+  if (temporaryId && !/^[0-9a-f-]{36}$/i.test(temporaryId)) throw new Error("\u65E0\u6548\u7684\u7F13\u5B58\u4E34\u65F6\u6807\u8BC6");
+  const temporaryFile = `${file}.${process.pid}.${temporaryId ?? import_node_crypto.default.randomUUID()}.tmp`;
+  try {
+    import_node_fs.default.writeFileSync(temporaryFile, (0, import_node_zlib.gzipSync)(text));
+    import_node_fs.default.renameSync(temporaryFile, file);
+  } finally {
+    import_node_fs.default.rmSync(temporaryFile, { force: true });
+  }
+}
+
+// src/dts-cache-worker.ts
+var entries = /* @__PURE__ */ new Map();
+function observe(input) {
+  const entry = { snapshot: void 0, dirty: false, watchers: [] };
+  for (const directory of [input.root, import_node_path2.default.join(input.root, "node_modules")]) {
+    try {
+      entry.watchers.push(import_node_fs2.default.watch(directory, { persistent: false }, (_event, filename) => {
+        if (!filename) {
+          entry.dirty = true;
+          return;
+        }
+        const name = filename.toString();
+        const base = import_node_path2.default.basename(name);
+        if (base.startsWith(".fulgurjs-types-") || [".cache", ".vite", ".vite-temp", ".git", ".svn", "node_modules"].includes(base) || /\.timestamp-\d+.*\.[cm]?js$/.test(base) || /\.(?:log|md|png|jpe?g|svg|tmp)$/.test(base)) return;
+        entry.dirty = true;
+      }));
+    } catch {
+    }
+  }
+  return entry;
+}
+function close(entry) {
+  for (const watcher of entry.watchers) watcher.close();
+}
+function externalInputs(input, snapshot) {
+  const outside = (file) => {
+    const relative = import_node_path2.default.relative(input.root, file);
+    return (relative === ".." || relative.startsWith(`..${import_node_path2.default.sep}`) || import_node_path2.default.isAbsolute(relative)) && !file.split(import_node_path2.default.sep).includes("node_modules");
+  };
+  const files = new Set(Object.keys(snapshot.files).filter(outside));
+  for (const [directory, queries] of Object.entries(snapshot.fileQueries)) {
+    if (!outside(directory)) continue;
+    for (const name of Object.keys(queries)) if (/\.(?:[cm]?[jt]sx?|vue|json|ya?ml|lock)$/.test(name)) files.add(import_node_path2.default.join(directory, name));
+  }
+  return [...files];
+}
+import_node_worker_threads.parentPort?.on("message", (message) => {
+  const { id, operation, input } = message;
+  try {
+    let value;
+    if (operation === "read" || operation === "capture") {
+      const observed = observe(input);
+      const cached = operation === "read" ? readTypesCache(input, false) : null;
+      const snapshot = cached?.snapshot ?? (operation === "capture" ? captureTypesInputs(input) : null);
+      if (!snapshot) {
+        close(observed);
+        value = null;
+      } else {
+        observed.snapshot = snapshot;
+        entries.set(id, observed);
+        value = { token: id, externalInputs: externalInputs(input, snapshot), ...cached ? { result: cached.result } : {} };
+      }
+    } else {
+      const entry = entries.get(message.token);
+      if (!entry) throw new Error("\u7C7B\u578B\u7F13\u5B58\u540E\u53F0\u5FEB\u7167\u5DF2\u91CA\u653E");
+      if (operation === "validate") value = entry.dirty ? "\u8F93\u5165\u4E8B\u4EF6\u5DF2\u53D8\u5316" : validateTypesInputs(entry.snapshot, input.root, message.stable);
+      else if (operation === "write") {
+        if (entry.dirty) value = false;
+        else {
+          writeTypesCache(input, entry.snapshot, message.result, message.temporaryId);
+          value = true;
+        }
+      } else if (operation === "release") {
+        close(entry);
+        entries.delete(message.token);
+        value = true;
+      } else throw new Error("\u672A\u77E5\u7684\u7C7B\u578B\u7F13\u5B58\u540E\u53F0\u64CD\u4F5C");
+    }
+    import_node_worker_threads.parentPort?.postMessage({ id, ok: true, value });
+  } catch (error) {
+    import_node_worker_threads.parentPort?.postMessage({ id, ok: false, error: error.message });
+  }
+});