@fulgurjs/federation 6.9.3 → 6.10.1

package/dist/cli.js

@@ -175,6 +175,1150 @@ var init_manifest = __esm({
   }
 });
 
+// node_modules/es-module-lexer/dist/lexer.js
+function parse(E2, g = "@") {
+  if (!C) return init.then((() => parse(E2)));
+  const I = E2.length + 1, w = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
+  w > 0 && C.memory.grow(Math.ceil(w / 65536));
+  const K = C.sa(I - 1);
+  if ((A ? B : Q)(E2, new Uint16Array(C.memory.buffer, K, I)), !C.parse()) throw Object.assign(new Error(`Parse error ${g}:${E2.slice(0, C.e()).split("\n").length}:${C.e() - E2.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
+  const o = [], D = [];
+  for (; C.ri(); ) {
+    const A2 = C.is(), Q2 = C.ie(), B2 = C.it(), g2 = C.ai(), I2 = C.id(), w2 = C.ss(), K2 = C.se();
+    let D2;
+    C.ip() && (D2 = k(E2.slice(-1 === I2 ? A2 - 1 : A2, -1 === I2 ? Q2 + 1 : Q2))), o.push({ n: D2, t: B2, s: A2, e: Q2, ss: w2, se: K2, d: I2, a: g2 });
+  }
+  for (; C.re(); ) {
+    const A2 = C.es(), Q2 = C.ee(), B2 = C.els(), g2 = C.ele(), I2 = E2.slice(A2, Q2), w2 = I2[0], K2 = B2 < 0 ? void 0 : E2.slice(B2, g2), o2 = K2 ? K2[0] : "";
+    D.push({ s: A2, e: Q2, ls: B2, le: g2, n: '"' === w2 || "'" === w2 ? k(I2) : I2, ln: '"' === o2 || "'" === o2 ? k(K2) : K2 });
+  }
+  function k(A2) {
+    try {
+      return (0, eval)(A2);
+    } catch (A3) {
+    }
+  }
+  return [o, D, !!C.f(), !!C.ms()];
+}
+function Q(A2, Q2) {
+  const B2 = A2.length;
+  let C2 = 0;
+  for (; C2 < B2; ) {
+    const B3 = A2.charCodeAt(C2);
+    Q2[C2++] = (255 & B3) << 8 | B3 >>> 8;
+  }
+}
+function B(A2, Q2) {
+  const B2 = A2.length;
+  let C2 = 0;
+  for (; C2 < B2; ) Q2[C2] = A2.charCodeAt(C2++);
+}
+var ImportType, A, C, E, init;
+var init_lexer = __esm({
+  "node_modules/es-module-lexer/dist/lexer.js"() {
+    !(function(A2) {
+      A2[A2.Static = 1] = "Static", A2[A2.Dynamic = 2] = "Dynamic", A2[A2.ImportMeta = 3] = "ImportMeta", A2[A2.StaticSourcePhase = 4] = "StaticSourcePhase", A2[A2.DynamicSourcePhase = 5] = "DynamicSourcePhase", A2[A2.StaticDeferPhase = 6] = "StaticDeferPhase", A2[A2.DynamicDeferPhase = 7] = "DynamicDeferPhase";
+    })(ImportType || (ImportType = {}));
+    A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
+    E = () => {
+      return A2 = "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", "undefined" != typeof Buffer ? Buffer.from(A2, "base64") : Uint8Array.from(atob(A2), ((A3) => A3.charCodeAt(0)));
+      var A2;
+    };
+    init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({ exports: A2 }) => {
+      C = A2;
+    }));
+  }
+});
+
+// node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+function encodeInteger(builder, num) {
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (num > 0);
+}
+function encodeSign(num) {
+  return num < 0 ? -num << 1 | 1 : num << 1;
+}
+function encode(decoded) {
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      encodeInteger(writer, encodeSign(segment[0] - genColumn));
+      genColumn = segment[0];
+      if (segment.length === 1) continue;
+      encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+      encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+      encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+      sourcesIndex = segment[1];
+      sourceLine = segment[2];
+      sourceColumn = segment[3];
+      if (segment.length === 4) continue;
+      encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+      namesIndex = segment[4];
+    }
+  }
+  return writer.flush();
+}
+var comma, semicolon, chars, intToChar, charToInt, bufLength, td, StringWriter;
+var init_sourcemap_codec = __esm({
+  "node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs"() {
+    comma = ",".charCodeAt(0);
+    semicolon = ";".charCodeAt(0);
+    chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    intToChar = new Uint8Array(64);
+    charToInt = new Uint8Array(128);
+    for (let i = 0; i < chars.length; i++) {
+      const c = chars.charCodeAt(i);
+      intToChar[i] = c;
+      charToInt[c] = i;
+    }
+    bufLength = 1024 * 16;
+    td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+      decode(buf) {
+        const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+        return out.toString();
+      }
+    } : {
+      decode(buf) {
+        let out = "";
+        for (let i = 0; i < buf.length; i++) {
+          out += String.fromCharCode(buf[i]);
+        }
+        return out;
+      }
+    };
+    StringWriter = class {
+      constructor() {
+        this.pos = 0;
+        this.out = "";
+        this.buffer = new Uint8Array(bufLength);
+      }
+      write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+          this.out += td.decode(buffer);
+          this.pos = 0;
+        }
+      }
+      flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+      }
+    };
+  }
+});
+
+// node_modules/magic-string/dist/magic-string.es.mjs
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  } else if (typeof Buffer === "function") {
+    return (str) => Buffer.from(str, "utf-8").toString("base64");
+  } else {
+    return () => {
+      throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+    };
+  }
+}
+function guessIndent(code) {
+  const lines = code.split("\n");
+  const tabbed = lines.filter((line) => /^\t+/.test(line));
+  const spaced = lines.filter((line) => /^ {2,}/.test(line));
+  if (tabbed.length === 0 && spaced.length === 0) {
+    return null;
+  }
+  if (tabbed.length >= spaced.length) {
+    return "	";
+  }
+  const min = spaced.reduce((previous, current) => {
+    const numSpaces = /^ +/.exec(current)[0].length;
+    return Math.min(numSpaces, previous);
+  }, Infinity);
+  return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+  const fromParts = from.split(/[/\\]/);
+  const toParts = to.split(/[/\\]/);
+  fromParts.pop();
+  while (fromParts[0] === toParts[0]) {
+    fromParts.shift();
+    toParts.shift();
+  }
+  if (fromParts.length) {
+    let i = fromParts.length;
+    while (i--) fromParts[i] = "..";
+  }
+  return fromParts.concat(toParts).join("/");
+}
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+  const originalLines = source.split("\n");
+  const lineOffsets = [];
+  for (let i = 0, pos = 0; i < originalLines.length; i++) {
+    lineOffsets.push(pos);
+    pos += originalLines[i].length + 1;
+  }
+  return function locate(index) {
+    let i = 0;
+    let j = lineOffsets.length;
+    while (i < j) {
+      const m = i + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
+      } else {
+        i = m + 1;
+      }
+    }
+    const line = i - 1;
+    const column = index - lineOffsets[line];
+    return { line, column };
+  };
+}
+var BitSet, Chunk, btoa, SourceMap, toString, wordRegex, Mappings, n, warned, MagicString;
+var init_magic_string_es = __esm({
+  "node_modules/magic-string/dist/magic-string.es.mjs"() {
+    init_sourcemap_codec();
+    BitSet = class _BitSet {
+      constructor(arg) {
+        this.bits = arg instanceof _BitSet ? arg.bits.slice() : [];
+      }
+      add(n2) {
+        this.bits[n2 >> 5] |= 1 << (n2 & 31);
+      }
+      has(n2) {
+        return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
+      }
+    };
+    Chunk = class _Chunk {
+      constructor(start, end, content) {
+        this.start = start;
+        this.end = end;
+        this.original = content;
+        this.intro = "";
+        this.outro = "";
+        this.content = content;
+        this.storeName = false;
+        this.edited = false;
+        {
+          this.previous = null;
+          this.next = null;
+        }
+      }
+      appendLeft(content) {
+        this.outro += content;
+      }
+      appendRight(content) {
+        this.intro = this.intro + content;
+      }
+      clone() {
+        const chunk = new _Chunk(this.start, this.end, this.original);
+        chunk.intro = this.intro;
+        chunk.outro = this.outro;
+        chunk.content = this.content;
+        chunk.storeName = this.storeName;
+        chunk.edited = this.edited;
+        return chunk;
+      }
+      contains(index) {
+        return this.start < index && index < this.end;
+      }
+      eachNext(fn) {
+        let chunk = this;
+        while (chunk) {
+          fn(chunk);
+          chunk = chunk.next;
+        }
+      }
+      eachPrevious(fn) {
+        let chunk = this;
+        while (chunk) {
+          fn(chunk);
+          chunk = chunk.previous;
+        }
+      }
+      edit(content, storeName, contentOnly) {
+        this.content = content;
+        if (!contentOnly) {
+          this.intro = "";
+          this.outro = "";
+        }
+        this.storeName = storeName;
+        this.edited = true;
+        return this;
+      }
+      prependLeft(content) {
+        this.outro = content + this.outro;
+      }
+      prependRight(content) {
+        this.intro = content + this.intro;
+      }
+      reset() {
+        this.intro = "";
+        this.outro = "";
+        if (this.edited) {
+          this.content = this.original;
+          this.storeName = false;
+          this.edited = false;
+        }
+      }
+      split(index) {
+        const sliceIndex = index - this.start;
+        const originalBefore = this.original.slice(0, sliceIndex);
+        const originalAfter = this.original.slice(sliceIndex);
+        this.original = originalBefore;
+        const newChunk = new _Chunk(index, this.end, originalAfter);
+        newChunk.outro = this.outro;
+        this.outro = "";
+        this.end = index;
+        if (this.edited) {
+          newChunk.edit("", false);
+          this.content = "";
+        } else {
+          this.content = originalBefore;
+        }
+        newChunk.next = this.next;
+        if (newChunk.next) newChunk.next.previous = newChunk;
+        newChunk.previous = this;
+        this.next = newChunk;
+        return newChunk;
+      }
+      toString() {
+        return this.intro + this.content + this.outro;
+      }
+      trimEnd(rx) {
+        this.outro = this.outro.replace(rx, "");
+        if (this.outro.length) return true;
+        const trimmed = this.content.replace(rx, "");
+        if (trimmed.length) {
+          if (trimmed !== this.content) {
+            this.split(this.start + trimmed.length).edit("", void 0, true);
+            if (this.edited) {
+              this.edit(trimmed, this.storeName, true);
+            }
+          }
+          return true;
+        } else {
+          this.edit("", void 0, true);
+          this.intro = this.intro.replace(rx, "");
+          if (this.intro.length) return true;
+        }
+      }
+      trimStart(rx) {
+        this.intro = this.intro.replace(rx, "");
+        if (this.intro.length) return true;
+        const trimmed = this.content.replace(rx, "");
+        if (trimmed.length) {
+          if (trimmed !== this.content) {
+            const newChunk = this.split(this.end - trimmed.length);
+            if (this.edited) {
+              newChunk.edit(trimmed, this.storeName, true);
+            }
+            this.edit("", void 0, true);
+          }
+          return true;
+        } else {
+          this.edit("", void 0, true);
+          this.outro = this.outro.replace(rx, "");
+          if (this.outro.length) return true;
+        }
+      }
+    };
+    btoa = /* @__PURE__ */ getBtoa();
+    SourceMap = class {
+      constructor(properties) {
+        this.version = 3;
+        this.file = properties.file;
+        this.sources = properties.sources;
+        this.sourcesContent = properties.sourcesContent;
+        this.names = properties.names;
+        this.mappings = encode(properties.mappings);
+        if (typeof properties.x_google_ignoreList !== "undefined") {
+          this.x_google_ignoreList = properties.x_google_ignoreList;
+        }
+        if (typeof properties.debugId !== "undefined") {
+          this.debugId = properties.debugId;
+        }
+      }
+      toString() {
+        return JSON.stringify(this);
+      }
+      toUrl() {
+        return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+      }
+    };
+    toString = Object.prototype.toString;
+    wordRegex = /\w/;
+    Mappings = class {
+      constructor(hires) {
+        this.hires = hires;
+        this.generatedCodeLine = 0;
+        this.generatedCodeColumn = 0;
+        this.raw = [];
+        this.rawSegments = this.raw[this.generatedCodeLine] = [];
+        this.pending = null;
+      }
+      addEdit(sourceIndex, content, loc, nameIndex) {
+        if (content.length) {
+          const contentLengthMinusOne = content.length - 1;
+          let contentLineEnd = content.indexOf("\n", 0);
+          let previousContentLineEnd = -1;
+          while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+            const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+            if (nameIndex >= 0) {
+              segment2.push(nameIndex);
+            }
+            this.rawSegments.push(segment2);
+            this.generatedCodeLine += 1;
+            this.raw[this.generatedCodeLine] = this.rawSegments = [];
+            this.generatedCodeColumn = 0;
+            previousContentLineEnd = contentLineEnd;
+            contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+          }
+          const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+          if (nameIndex >= 0) {
+            segment.push(nameIndex);
+          }
+          this.rawSegments.push(segment);
+          this.advance(content.slice(previousContentLineEnd + 1));
+        } else if (this.pending) {
+          this.rawSegments.push(this.pending);
+          this.advance(content);
+        }
+        this.pending = null;
+      }
+      addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+        let originalCharIndex = chunk.start;
+        let first = true;
+        let charInHiresBoundary = false;
+        while (originalCharIndex < chunk.end) {
+          if (original[originalCharIndex] === "\n") {
+            loc.line += 1;
+            loc.column = 0;
+            this.generatedCodeLine += 1;
+            this.raw[this.generatedCodeLine] = this.rawSegments = [];
+            this.generatedCodeColumn = 0;
+            first = true;
+            charInHiresBoundary = false;
+          } else {
+            if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+              const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+              if (this.hires === "boundary") {
+                if (wordRegex.test(original[originalCharIndex])) {
+                  if (!charInHiresBoundary) {
+                    this.rawSegments.push(segment);
+                    charInHiresBoundary = true;
+                  }
+                } else {
+                  this.rawSegments.push(segment);
+                  charInHiresBoundary = false;
+                }
+              } else {
+                this.rawSegments.push(segment);
+              }
+            }
+            loc.column += 1;
+            this.generatedCodeColumn += 1;
+            first = false;
+          }
+          originalCharIndex += 1;
+        }
+        this.pending = null;
+      }
+      advance(str) {
+        if (!str) return;
+        const lines = str.split("\n");
+        if (lines.length > 1) {
+          for (let i = 0; i < lines.length - 1; i++) {
+            this.generatedCodeLine++;
+            this.raw[this.generatedCodeLine] = this.rawSegments = [];
+          }
+          this.generatedCodeColumn = 0;
+        }
+        this.generatedCodeColumn += lines[lines.length - 1].length;
+      }
+    };
+    n = "\n";
+    warned = {
+      insertLeft: false,
+      insertRight: false,
+      storeName: false
+    };
+    MagicString = class _MagicString {
+      constructor(string, options = {}) {
+        const chunk = new Chunk(0, string.length, string);
+        Object.defineProperties(this, {
+          original: { writable: true, value: string },
+          outro: { writable: true, value: "" },
+          intro: { writable: true, value: "" },
+          firstChunk: { writable: true, value: chunk },
+          lastChunk: { writable: true, value: chunk },
+          lastSearchedChunk: { writable: true, value: chunk },
+          byStart: { writable: true, value: {} },
+          byEnd: { writable: true, value: {} },
+          filename: { writable: true, value: options.filename },
+          indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+          sourcemapLocations: { writable: true, value: new BitSet() },
+          storedNames: { writable: true, value: {} },
+          indentStr: { writable: true, value: void 0 },
+          ignoreList: { writable: true, value: options.ignoreList },
+          offset: { writable: true, value: options.offset || 0 }
+        });
+        this.byStart[0] = chunk;
+        this.byEnd[string.length] = chunk;
+      }
+      addSourcemapLocation(char) {
+        this.sourcemapLocations.add(char);
+      }
+      append(content) {
+        if (typeof content !== "string") throw new TypeError("outro content must be a string");
+        this.outro += content;
+        return this;
+      }
+      appendLeft(index, content) {
+        index = index + this.offset;
+        if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+        this._split(index);
+        const chunk = this.byEnd[index];
+        if (chunk) {
+          chunk.appendLeft(content);
+        } else {
+          this.intro += content;
+        }
+        return this;
+      }
+      appendRight(index, content) {
+        index = index + this.offset;
+        if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+        this._split(index);
+        const chunk = this.byStart[index];
+        if (chunk) {
+          chunk.appendRight(content);
+        } else {
+          this.outro += content;
+        }
+        return this;
+      }
+      clone() {
+        const cloned = new _MagicString(this.original, { filename: this.filename, offset: this.offset });
+        let originalChunk = this.firstChunk;
+        let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+        while (originalChunk) {
+          cloned.byStart[clonedChunk.start] = clonedChunk;
+          cloned.byEnd[clonedChunk.end] = clonedChunk;
+          const nextOriginalChunk = originalChunk.next;
+          const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+          if (nextClonedChunk) {
+            clonedChunk.next = nextClonedChunk;
+            nextClonedChunk.previous = clonedChunk;
+            clonedChunk = nextClonedChunk;
+          }
+          originalChunk = nextOriginalChunk;
+        }
+        cloned.lastChunk = clonedChunk;
+        if (this.indentExclusionRanges) {
+          cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+        }
+        cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+        cloned.intro = this.intro;
+        cloned.outro = this.outro;
+        return cloned;
+      }
+      generateDecodedMap(options) {
+        options = options || {};
+        const sourceIndex = 0;
+        const names = Object.keys(this.storedNames);
+        const mappings = new Mappings(options.hires);
+        const locate = getLocator(this.original);
+        if (this.intro) {
+          mappings.advance(this.intro);
+        }
+        this.firstChunk.eachNext((chunk) => {
+          const loc = locate(chunk.start);
+          if (chunk.intro.length) mappings.advance(chunk.intro);
+          if (chunk.edited) {
+            mappings.addEdit(
+              sourceIndex,
+              chunk.content,
+              loc,
+              chunk.storeName ? names.indexOf(chunk.original) : -1
+            );
+          } else {
+            mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+          }
+          if (chunk.outro.length) mappings.advance(chunk.outro);
+        });
+        if (this.outro) {
+          mappings.advance(this.outro);
+        }
+        return {
+          file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+          sources: [
+            options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+          ],
+          sourcesContent: options.includeContent ? [this.original] : void 0,
+          names,
+          mappings: mappings.raw,
+          x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+        };
+      }
+      generateMap(options) {
+        return new SourceMap(this.generateDecodedMap(options));
+      }
+      _ensureindentStr() {
+        if (this.indentStr === void 0) {
+          this.indentStr = guessIndent(this.original);
+        }
+      }
+      _getRawIndentString() {
+        this._ensureindentStr();
+        return this.indentStr;
+      }
+      getIndentString() {
+        this._ensureindentStr();
+        return this.indentStr === null ? "	" : this.indentStr;
+      }
+      indent(indentStr, options) {
+        const pattern = /^[^\r\n]/gm;
+        if (isObject(indentStr)) {
+          options = indentStr;
+          indentStr = void 0;
+        }
+        if (indentStr === void 0) {
+          this._ensureindentStr();
+          indentStr = this.indentStr || "	";
+        }
+        if (indentStr === "") return this;
+        options = options || {};
+        const isExcluded2 = {};
+        if (options.exclude) {
+          const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+          exclusions.forEach((exclusion) => {
+            for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+              isExcluded2[i] = true;
+            }
+          });
+        }
+        let shouldIndentNextCharacter = options.indentStart !== false;
+        const replacer = (match) => {
+          if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+          shouldIndentNextCharacter = true;
+          return match;
+        };
+        this.intro = this.intro.replace(pattern, replacer);
+        let charIndex = 0;
+        let chunk = this.firstChunk;
+        while (chunk) {
+          const end = chunk.end;
+          if (chunk.edited) {
+            if (!isExcluded2[charIndex]) {
+              chunk.content = chunk.content.replace(pattern, replacer);
+              if (chunk.content.length) {
+                shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+              }
+            }
+          } else {
+            charIndex = chunk.start;
+            while (charIndex < end) {
+              if (!isExcluded2[charIndex]) {
+                const char = this.original[charIndex];
+                if (char === "\n") {
+                  shouldIndentNextCharacter = true;
+                } else if (char !== "\r" && shouldIndentNextCharacter) {
+                  shouldIndentNextCharacter = false;
+                  if (charIndex === chunk.start) {
+                    chunk.prependRight(indentStr);
+                  } else {
+                    this._splitChunk(chunk, charIndex);
+                    chunk = chunk.next;
+                    chunk.prependRight(indentStr);
+                  }
+                }
+              }
+              charIndex += 1;
+            }
+          }
+          charIndex = chunk.end;
+          chunk = chunk.next;
+        }
+        this.outro = this.outro.replace(pattern, replacer);
+        return this;
+      }
+      insert() {
+        throw new Error(
+          "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+        );
+      }
+      insertLeft(index, content) {
+        if (!warned.insertLeft) {
+          console.warn(
+            "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+          );
+          warned.insertLeft = true;
+        }
+        return this.appendLeft(index, content);
+      }
+      insertRight(index, content) {
+        if (!warned.insertRight) {
+          console.warn(
+            "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+          );
+          warned.insertRight = true;
+        }
+        return this.prependRight(index, content);
+      }
+      move(start, end, index) {
+        start = start + this.offset;
+        end = end + this.offset;
+        index = index + this.offset;
+        if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
+        this._split(start);
+        this._split(end);
+        this._split(index);
+        const first = this.byStart[start];
+        const last = this.byEnd[end];
+        const oldLeft = first.previous;
+        const oldRight = last.next;
+        const newRight = this.byStart[index];
+        if (!newRight && last === this.lastChunk) return this;
+        const newLeft = newRight ? newRight.previous : this.lastChunk;
+        if (oldLeft) oldLeft.next = oldRight;
+        if (oldRight) oldRight.previous = oldLeft;
+        if (newLeft) newLeft.next = first;
+        if (newRight) newRight.previous = last;
+        if (!first.previous) this.firstChunk = last.next;
+        if (!last.next) {
+          this.lastChunk = first.previous;
+          this.lastChunk.next = null;
+        }
+        first.previous = newLeft;
+        last.next = newRight || null;
+        if (!newLeft) this.firstChunk = first;
+        if (!newRight) this.lastChunk = last;
+        return this;
+      }
+      overwrite(start, end, content, options) {
+        options = options || {};
+        return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+      }
+      update(start, end, content, options) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (typeof content !== "string") throw new TypeError("replacement content must be a string");
+        if (this.original.length !== 0) {
+          while (start < 0) start += this.original.length;
+          while (end < 0) end += this.original.length;
+        }
+        if (end > this.original.length) throw new Error("end is out of bounds");
+        if (start === end)
+          throw new Error(
+            "Cannot overwrite a zero-length range \u2013 use appendLeft or prependRight instead"
+          );
+        this._split(start);
+        this._split(end);
+        if (options === true) {
+          if (!warned.storeName) {
+            console.warn(
+              "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+            );
+            warned.storeName = true;
+          }
+          options = { storeName: true };
+        }
+        const storeName = options !== void 0 ? options.storeName : false;
+        const overwrite = options !== void 0 ? options.overwrite : false;
+        if (storeName) {
+          const original = this.original.slice(start, end);
+          Object.defineProperty(this.storedNames, original, {
+            writable: true,
+            value: true,
+            enumerable: true
+          });
+        }
+        const first = this.byStart[start];
+        const last = this.byEnd[end];
+        if (first) {
+          let chunk = first;
+          while (chunk !== last) {
+            if (chunk.next !== this.byStart[chunk.end]) {
+              throw new Error("Cannot overwrite across a split point");
+            }
+            chunk = chunk.next;
+            chunk.edit("", false);
+          }
+          first.edit(content, storeName, !overwrite);
+        } else {
+          const newChunk = new Chunk(start, end, "").edit(content, storeName);
+          last.next = newChunk;
+          newChunk.previous = last;
+        }
+        return this;
+      }
+      prepend(content) {
+        if (typeof content !== "string") throw new TypeError("outro content must be a string");
+        this.intro = content + this.intro;
+        return this;
+      }
+      prependLeft(index, content) {
+        index = index + this.offset;
+        if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+        this._split(index);
+        const chunk = this.byEnd[index];
+        if (chunk) {
+          chunk.prependLeft(content);
+        } else {
+          this.intro = content + this.intro;
+        }
+        return this;
+      }
+      prependRight(index, content) {
+        index = index + this.offset;
+        if (typeof content !== "string") throw new TypeError("inserted content must be a string");
+        this._split(index);
+        const chunk = this.byStart[index];
+        if (chunk) {
+          chunk.prependRight(content);
+        } else {
+          this.outro = content + this.outro;
+        }
+        return this;
+      }
+      remove(start, end) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+          while (start < 0) start += this.original.length;
+          while (end < 0) end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+        if (start > end) throw new Error("end must be greater than start");
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while (chunk) {
+          chunk.intro = "";
+          chunk.outro = "";
+          chunk.edit("");
+          chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+      }
+      reset(start, end) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+          while (start < 0) start += this.original.length;
+          while (end < 0) end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
+        if (start > end) throw new Error("end must be greater than start");
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while (chunk) {
+          chunk.reset();
+          chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+      }
+      lastChar() {
+        if (this.outro.length) return this.outro[this.outro.length - 1];
+        let chunk = this.lastChunk;
+        do {
+          if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+          if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+          if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+        } while (chunk = chunk.previous);
+        if (this.intro.length) return this.intro[this.intro.length - 1];
+        return "";
+      }
+      lastLine() {
+        let lineIndex = this.outro.lastIndexOf(n);
+        if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+        let lineStr = this.outro;
+        let chunk = this.lastChunk;
+        do {
+          if (chunk.outro.length > 0) {
+            lineIndex = chunk.outro.lastIndexOf(n);
+            if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+            lineStr = chunk.outro + lineStr;
+          }
+          if (chunk.content.length > 0) {
+            lineIndex = chunk.content.lastIndexOf(n);
+            if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+            lineStr = chunk.content + lineStr;
+          }
+          if (chunk.intro.length > 0) {
+            lineIndex = chunk.intro.lastIndexOf(n);
+            if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+            lineStr = chunk.intro + lineStr;
+          }
+        } while (chunk = chunk.previous);
+        lineIndex = this.intro.lastIndexOf(n);
+        if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+        return this.intro + lineStr;
+      }
+      slice(start = 0, end = this.original.length - this.offset) {
+        start = start + this.offset;
+        end = end + this.offset;
+        if (this.original.length !== 0) {
+          while (start < 0) start += this.original.length;
+          while (end < 0) end += this.original.length;
+        }
+        let result = "";
+        let chunk = this.firstChunk;
+        while (chunk && (chunk.start > start || chunk.end <= start)) {
+          if (chunk.start < end && chunk.end >= end) {
+            return result;
+          }
+          chunk = chunk.next;
+        }
+        if (chunk && chunk.edited && chunk.start !== start)
+          throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+        const startChunk = chunk;
+        while (chunk) {
+          if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+            result += chunk.intro;
+          }
+          const containsEnd = chunk.start < end && chunk.end >= end;
+          if (containsEnd && chunk.edited && chunk.end !== end)
+            throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+          const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+          const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+          result += chunk.content.slice(sliceStart, sliceEnd);
+          if (chunk.outro && (!containsEnd || chunk.end === end)) {
+            result += chunk.outro;
+          }
+          if (containsEnd) {
+            break;
+          }
+          chunk = chunk.next;
+        }
+        return result;
+      }
+      // TODO deprecate this? not really very useful
+      snip(start, end) {
+        const clone = this.clone();
+        clone.remove(0, start);
+        clone.remove(end, clone.original.length);
+        return clone;
+      }
+      _split(index) {
+        if (this.byStart[index] || this.byEnd[index]) return;
+        let chunk = this.lastSearchedChunk;
+        let previousChunk = chunk;
+        const searchForward = index > chunk.end;
+        while (chunk) {
+          if (chunk.contains(index)) return this._splitChunk(chunk, index);
+          chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+          if (chunk === previousChunk) return;
+          previousChunk = chunk;
+        }
+      }
+      _splitChunk(chunk, index) {
+        if (chunk.edited && chunk.content.length) {
+          const loc = getLocator(this.original)(index);
+          throw new Error(
+            `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`
+          );
+        }
+        const newChunk = chunk.split(index);
+        this.byEnd[index] = chunk;
+        this.byStart[index] = newChunk;
+        this.byEnd[newChunk.end] = newChunk;
+        if (chunk === this.lastChunk) this.lastChunk = newChunk;
+        this.lastSearchedChunk = chunk;
+        return true;
+      }
+      toString() {
+        let str = this.intro;
+        let chunk = this.firstChunk;
+        while (chunk) {
+          str += chunk.toString();
+          chunk = chunk.next;
+        }
+        return str + this.outro;
+      }
+      isEmpty() {
+        let chunk = this.firstChunk;
+        do {
+          if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim())
+            return false;
+        } while (chunk = chunk.next);
+        return true;
+      }
+      length() {
+        let chunk = this.firstChunk;
+        let length = 0;
+        do {
+          length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+        } while (chunk = chunk.next);
+        return length;
+      }
+      trimLines() {
+        return this.trim("[\\r\\n]");
+      }
+      trim(charType) {
+        return this.trimStart(charType).trimEnd(charType);
+      }
+      trimEndAborted(charType) {
+        const rx = new RegExp((charType || "\\s") + "+$");
+        this.outro = this.outro.replace(rx, "");
+        if (this.outro.length) return true;
+        let chunk = this.lastChunk;
+        do {
+          const end = chunk.end;
+          const aborted = chunk.trimEnd(rx);
+          if (chunk.end !== end) {
+            if (this.lastChunk === chunk) {
+              this.lastChunk = chunk.next;
+            }
+            this.byEnd[chunk.end] = chunk;
+            this.byStart[chunk.next.start] = chunk.next;
+            this.byEnd[chunk.next.end] = chunk.next;
+          }
+          if (aborted) return true;
+          chunk = chunk.previous;
+        } while (chunk);
+        return false;
+      }
+      trimEnd(charType) {
+        this.trimEndAborted(charType);
+        return this;
+      }
+      trimStartAborted(charType) {
+        const rx = new RegExp("^" + (charType || "\\s") + "+");
+        this.intro = this.intro.replace(rx, "");
+        if (this.intro.length) return true;
+        let chunk = this.firstChunk;
+        do {
+          const end = chunk.end;
+          const aborted = chunk.trimStart(rx);
+          if (chunk.end !== end) {
+            if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+            this.byEnd[chunk.end] = chunk;
+            this.byStart[chunk.next.start] = chunk.next;
+            this.byEnd[chunk.next.end] = chunk.next;
+          }
+          if (aborted) return true;
+          chunk = chunk.next;
+        } while (chunk);
+        return false;
+      }
+      trimStart(charType) {
+        this.trimStartAborted(charType);
+        return this;
+      }
+      hasChanged() {
+        return this.original !== this.toString();
+      }
+      _replaceRegexp(searchValue, replacement) {
+        function getReplacement(match, str) {
+          if (typeof replacement === "string") {
+            return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+              if (i === "$") return "$";
+              if (i === "&") return match[0];
+              const num = +i;
+              if (num < match.length) return match[+i];
+              return `$${i}`;
+            });
+          } else {
+            return replacement(...match, match.index, str, match.groups);
+          }
+        }
+        function matchAll(re, str) {
+          let match;
+          const matches = [];
+          while (match = re.exec(str)) {
+            matches.push(match);
+          }
+          return matches;
+        }
+        if (searchValue.global) {
+          const matches = matchAll(searchValue, this.original);
+          matches.forEach((match) => {
+            if (match.index != null) {
+              const replacement2 = getReplacement(match, this.original);
+              if (replacement2 !== match[0]) {
+                this.overwrite(match.index, match.index + match[0].length, replacement2);
+              }
+            }
+          });
+        } else {
+          const match = this.original.match(searchValue);
+          if (match && match.index != null) {
+            const replacement2 = getReplacement(match, this.original);
+            if (replacement2 !== match[0]) {
+              this.overwrite(match.index, match.index + match[0].length, replacement2);
+            }
+          }
+        }
+        return this;
+      }
+      _replaceString(string, replacement) {
+        const { original } = this;
+        const index = original.indexOf(string);
+        if (index !== -1) {
+          if (typeof replacement === "function") {
+            replacement = replacement(string, index, original);
+          }
+          if (string !== replacement) {
+            this.overwrite(index, index + string.length, replacement);
+          }
+        }
+        return this;
+      }
+      replace(searchValue, replacement) {
+        if (typeof searchValue === "string") {
+          return this._replaceString(searchValue, replacement);
+        }
+        return this._replaceRegexp(searchValue, replacement);
+      }
+      _replaceAllString(string, replacement) {
+        const { original } = this;
+        const stringLength = string.length;
+        for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+          const previous = original.slice(index, index + stringLength);
+          let _replacement = replacement;
+          if (typeof replacement === "function") {
+            _replacement = replacement(previous, index, original);
+          }
+          if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
+        }
+        return this;
+      }
+      replaceAll(searchValue, replacement) {
+        if (typeof searchValue === "string") {
+          return this._replaceAllString(searchValue, replacement);
+        }
+        if (!searchValue.global) {
+          throw new TypeError(
+            "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+          );
+        }
+        return this._replaceRegexp(searchValue, replacement);
+      }
+    };
+  }
+});
+
 // src/app-config.ts
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
@@ -236,18 +1380,18 @@ function validateHostPages(value) {
   }
   return hp;
 }
-function validatePathsInsideApp(options, appRoot, fs11, path10) {
+function validatePathsInsideApp(options, appRoot, fs12, path12) {
   const checkModule = (field, value) => {
     if (typeof value !== "string" || value.trim() === "") return;
-    if (/^(https?:)?\/\//.test(value) || path10.isAbsolute(value)) {
+    if (/^(https?:)?\/\//.test(value) || path12.isAbsolute(value)) {
       appConfigError(
         `${field} "${value}" \u4E0D\u662F\u672C\u9879\u76EE\u5185\u7684\u6A21\u5757\u8DEF\u5F84`,
         "exposes/setup \u7684\u503C\u662F\u76F8\u5BF9\u672C\u5E94\u7528\u6839\u76EE\u5F55\u7684\u6E90\u6587\u4EF6\u8DEF\u5F84\uFF08URL/\u7EDD\u5BF9\u8DEF\u5F84\u65E0\u6CD5\u5728\u72EC\u7ACB\u4ED3\u5E93\u95F4\u79FB\u690D\uFF09",
         `\u6539\u4E3A\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u5982 './src/views/Home.vue'\uFF08\u914D\u7F6E\u6587\u4EF6\u76EE\u5F55 = \u5E94\u7528\u6839 ${appRoot}\uFF09`
       );
     }
-    const abs = path10.resolve(appRoot, value);
-    if (!fs11.existsSync(abs)) {
+    const abs = path12.resolve(appRoot, value);
+    if (!fs12.existsSync(abs)) {
       appConfigError(
         `${field} \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${value}`,
         `\u6309\u5E94\u7528\u6839 ${appRoot} \u89E3\u6790\u540E\u672A\u627E\u5230\u8BE5\u6587\u4EF6`,
@@ -316,11 +1460,11 @@ function resolveEsbuild(configPath) {
   );
 }
 async function loadAppConfig(configPath) {
-  const fs11 = await import("node:fs");
+  const fs12 = await import("node:fs");
   const os = await import("node:os");
-  const path10 = await import("node:path");
-  const abs = path10.resolve(configPath);
-  if (!fs11.existsSync(abs)) {
+  const path12 = await import("node:path");
+  const abs = path12.resolve(configPath);
+  if (!fs12.existsSync(abs)) {
     appConfigError(
       `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${abs}`,
       "--config \u6307\u5411\u7684\u8DEF\u5F84\u5728\u672C\u673A\u4E0D\u5B58\u5728\uFF08\u76F8\u5BF9\u8DEF\u5F84\u4EE5 CLI \u8FDB\u7A0B cwd \u89E3\u6790\uFF09",
@@ -328,11 +1472,11 @@ async function loadAppConfig(configPath) {
     );
   }
   if (abs.endsWith(".json")) {
-    const parsed = JSON.parse(fs11.readFileSync(abs, "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(abs, "utf8"));
     if (isAggregateShape(parsed)) aggregateMigrationError();
-    return finishAppShape(parsed, {}, abs, path10.dirname(abs), fs11, path10);
+    return finishAppShape(parsed, {}, abs, path12.dirname(abs), fs12, path12);
   }
-  const rawSource = fs11.readFileSync(abs, "utf8");
+  const rawSource = fs12.readFileSync(abs, "utf8");
   if (/@fulgurjs\/federation\/config/.test(rawSource)) {
     appConfigError(
       `\u914D\u7F6E\u5BFC\u5165\u4E86\u5DF2\u5220\u9664\u7684\u5B50\u8DEF\u5F84 "@fulgurjs/federation/config"`,
@@ -363,21 +1507,21 @@ async function loadAppConfig(configPath) {
     plugins: [selfRedirect],
     logLevel: "silent"
   });
-  const tmpDir = fs11.mkdtempSync(path10.join(os.tmpdir(), "fulgurjs-appcfg-"));
+  const tmpDir = fs12.mkdtempSync(path12.join(os.tmpdir(), "fulgurjs-appcfg-"));
   try {
-    const bundleFile = path10.join(tmpDir, "fulgurjs.config.bundle.mjs");
-    fs11.writeFileSync(bundleFile, out.outputFiles[0].text);
+    const bundleFile = path12.join(tmpDir, "fulgurjs.config.bundle.mjs");
+    fs12.writeFileSync(bundleFile, out.outputFiles[0].text);
     const mod = await import(
       /* @vite-ignore */
       `${pathToFileURL(bundleFile).href}?t=${Date.now()}`
     );
     if (isAggregateShape(mod.default)) aggregateMigrationError();
-    return finishAppShape(mod.default, { hostPages: mod.hostPages }, abs, path10.dirname(abs), fs11, path10);
+    return finishAppShape(mod.default, { hostPages: mod.hostPages }, abs, path12.dirname(abs), fs12, path12);
   } finally {
-    fs11.rmSync(tmpDir, { recursive: true, force: true });
+    fs12.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
-function finishAppShape(def, named, configPath, appRoot, fs11, path10) {
+function finishAppShape(def, named, configPath, appRoot, fs12, path12) {
   if (def === void 0 || def === null) {
     appConfigError(
       "fulgurjs.config.ts \u6CA1\u6709\u53EF\u7528\u7684\u9ED8\u8BA4\u5BFC\u51FA",
@@ -390,7 +1534,7 @@ function finishAppShape(def, named, configPath, appRoot, fs11, path10) {
   }
   const options = def;
   validateAppOptions(options);
-  validatePathsInsideApp(options, appRoot, fs11, path10);
+  validatePathsInsideApp(options, appRoot, fs12, path12);
   const hostPages = named.hostPages !== void 0 ? validateHostPages(named.hostPages) : void 0;
   return {
     kind: "app",
@@ -644,6 +1788,543 @@ var init_init = __esm({
   }
 });
 
+// src/init-plan.ts
+var init_plan_exports = {};
+__export(init_plan_exports, {
+  applyIntegration: () => applyIntegration,
+  formatIntegrationPlan: () => formatIntegrationPlan,
+  planIntegration: () => planIntegration,
+  rollbackIntegration: () => rollbackIntegration
+});
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+async function validateSource(file, source) {
+  const { transform } = requireHere("esbuild");
+  const loader = /\.tsx$/.test(file) ? "tsx" : /\.jsx$/.test(file) ? "jsx" : /\.[cm]?ts$/.test(file) ? "ts" : "js";
+  await transform(source, { loader, sourcefile: file, format: "esm", target: "es2022", logLevel: "silent" });
+}
+function rejectSymlink(file, label) {
+  try {
+    if (fs2.lstatSync(file).isSymbolicLink()) throw new Error(`\u4E0D\u6539\u5199\u7B26\u53F7\u94FE\u63A5\uFF1A${label}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+function tokens(source) {
+  const out = [];
+  for (let i = 0; i < source.length; ) {
+    const start = i, c = source[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (source.startsWith("//", i)) {
+      const end = source.indexOf("\n", i);
+      i = end < 0 ? source.length : end + 1;
+      continue;
+    }
+    if (source.startsWith("/*", i)) {
+      const end = source.indexOf("*/", i + 2);
+      if (end < 0) throw new Error("\u6CE8\u91CA\u672A\u95ED\u5408");
+      i = end + 2;
+      continue;
+    }
+    if (c === "`") {
+      i++;
+      while (i < source.length && source[i] !== "`") {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source.startsWith("${", i)) throw new Error("\u542B\u63D2\u503C\u6A21\u677F\uFF0C\u8BF7\u6309\u9884\u89C8\u4E2D\u7684\u63A5\u5165\u5757\u624B\u52A8\u4FEE\u6539\u914D\u7F6E");
+        i++;
+      }
+      if (i >= source.length) throw new Error("\u6A21\u677F\u672A\u95ED\u5408");
+      out.push({ value: source.slice(start + 1, i), start, end: ++i, literal: true });
+      continue;
+    }
+    if (c === "/") {
+      const previous = out.at(-1);
+      const regex = !previous || !previous.literal && ["=", ":", ",", "(", "[", "{", "!", "?", ">", "return"].includes(previous.value);
+      if (!regex) throw new Error("\u659C\u6760\u8868\u8FBE\u5F0F\u65E0\u6CD5\u786E\u5B9A\u662F\u6B63\u5219\u8FD8\u662F\u9664\u6CD5\uFF0C\u8BF7\u624B\u52A8\u5408\u5E76\u914D\u7F6E");
+      i++;
+      let inClass = false;
+      while (i < source.length) {
+        const char = source[i++];
+        if (char === "\\") {
+          i++;
+          continue;
+        }
+        if (char === "[") inClass = true;
+        else if (char === "]") inClass = false;
+        else if (char === "/" && !inClass) break;
+      }
+      while (i < source.length && /[a-z]/i.test(source[i])) i++;
+      out.push({ value: source.slice(start, i), start, end: i, literal: true });
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i++;
+      while (i < source.length && source[i] !== c) {
+        if (source[i] === "\\") throw new Error("\u542B\u8F6C\u4E49\u5B57\u7B26\u4E32\uFF0C\u8BF7\u4EBA\u5DE5\u786E\u8BA4\u914D\u7F6E");
+        i++;
+      }
+      if (i >= source.length) throw new Error("\u5B57\u7B26\u4E32\u672A\u95ED\u5408");
+      i++;
+      out.push({ value: source.slice(start + 1, i - 1), start, end: i, literal: true });
+      continue;
+    }
+    if (/[\w$]/.test(c)) {
+      while (i < source.length && /[\w$]/.test(source[i])) i++;
+      out.push({ value: source.slice(start, i), start, end: i });
+      continue;
+    }
+    if (source.startsWith("...", i)) {
+      out.push({ value: "...", start, end: i + 3 });
+      i += 3;
+      continue;
+    }
+    out.push({ value: c, start, end: ++i });
+  }
+  return out;
+}
+function closeAt(ts, at) {
+  const closes = { "{": "}", "[": "]", "(": ")" };
+  const stack = [];
+  for (let i = at; i < ts.length; i++) {
+    const token = ts[i];
+    if (token.literal) continue;
+    if (closes[token.value]) stack.push(closes[token.value]);
+    else if (["}", "]", ")"].includes(token.value) && stack.pop() !== token.value) throw new Error("\u65E0\u6CD5\u786E\u8BA4\u914D\u7F6E\u62EC\u53F7\u8FB9\u754C");
+    if (!stack.length) return i;
+  }
+  throw new Error("\u65E0\u6CD5\u786E\u8BA4\u914D\u7F6E\u7ED3\u675F\u4F4D\u7F6E");
+}
+async function wireVite(file, source) {
+  await validateSource(file, source);
+  await init;
+  const [imports] = parse(source);
+  const pluginImport = imports.find((item) => item.d === -1 && item.n === "@fulgurjs/federation");
+  if (pluginImport) throw new Error("\u5DF2\u6709 federation \u5BFC\u5165\uFF0C\u9700\u6838\u5B9E\u5B83\u662F\u5426\u5DF2\u5728\u5B9E\u9645 plugins \u4E2D\u6CE8\u518C\uFF1B\u4E0D\u4F1A\u91CD\u590D\u63D2\u5165\u53E6\u4E00\u5957\u914D\u7F6E");
+  const ts = tokens(source);
+  if (ts.some((t) => !t.literal && ["fulgurjsFederation", "fulgurjsConfig"].includes(t.value))) throw new Error("\u63A5\u5165\u53D8\u91CF\u540D\u5DF2\u88AB\u4F7F\u7528\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76\u914D\u7F6E");
+  const exports = ts.map((t, i) => t.value === "export" && !t.literal && ts[i + 1]?.value === "default" ? i : -1).filter((i) => i >= 0);
+  if (exports.length !== 1) throw new Error("\u9700\u8981\u552F\u4E00\u7684 export default \u914D\u7F6E");
+  let obj = exports[0] + 2;
+  let outerEnd = -1, expressionEnd = -1;
+  if (ts[obj]?.value !== "{" && ts[obj + 1]?.value === "(") {
+    const call = ts[obj]?.value;
+    const viteImport = imports.find((item) => item.d === -1 && item.n === "vite");
+    const declaration = viteImport ? source.slice(viteImport.ss, viteImport.se) : "";
+    const binding = declaration.match(/\bdefineConfig(?:\s+as\s+(\w+))?\b/);
+    if (!binding || call !== (binding[1] ?? "defineConfig")) throw new Error("\u81EA\u5B9A\u4E49\u914D\u7F6E\u5305\u88C5\u5668\u9700\u8981\u624B\u52A8\u5408\u5E76 federation \u63D2\u4EF6");
+    outerEnd = closeAt(ts, obj + 1);
+    obj += 2;
+  }
+  if (ts[obj]?.value !== "{") {
+    if (ts[obj]?.value === "async") throw new Error("\u5F02\u6B65\u914D\u7F6E\u9700\u624B\u52A8\u6838\u5B9E\u63D2\u4EF6\u6CE8\u518C");
+    let arrow = obj;
+    if (ts[arrow]?.value === "(") arrow = closeAt(ts, arrow) + 1;
+    else arrow++;
+    if (ts[arrow]?.value === ":") {
+      arrow++;
+      while (ts[arrow] && ts[arrow].value !== "=") arrow++;
+    }
+    if (ts[arrow]?.value !== "=" || ts[arrow + 1]?.value !== ">") throw new Error("\u914D\u7F6E\u4E0D\u662F\u53EF\u8BC6\u522B\u7684\u5BF9\u8C61\u6216\u7BAD\u5934\u5DE5\u5382\uFF0C\u8BF7\u624B\u52A8\u5408\u5E76");
+    let body = arrow + 2;
+    if (ts[body]?.value === "(" && ts[body + 1]?.value === "{") {
+      obj = body + 1;
+      expressionEnd = closeAt(ts, body);
+      if (closeAt(ts, obj) + 1 !== expressionEnd) throw new Error("\u914D\u7F6E\u4E0D\u662F\u5355\u4E2A\u8FD4\u56DE\u5BF9\u8C61\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76");
+      if (outerEnd < 0) outerEnd = expressionEnd;
+    } else {
+      if (ts[body]?.value !== "{") throw new Error("\u914D\u7F6E\u5DE5\u5382\u8FD4\u56DE\u53D8\u91CF\u6216\u590D\u6742\u8868\u8FBE\u5F0F\uFF0C\u8BF7\u624B\u52A8\u5408\u5E76");
+      const bodyEnd = closeAt(ts, body);
+      expressionEnd = bodyEnd;
+      if (outerEnd < 0) outerEnd = bodyEnd;
+      let found = -1;
+      for (let i = body + 1; i < bodyEnd; i++) {
+        if (!ts[i].literal && ["if", "switch", "try", "for", "while", "function"].includes(ts[i].value)) throw new Error("\u914D\u7F6E\u5DE5\u5382\u6709\u63A7\u5236\u6D41\u6216\u5C40\u90E8\u51FD\u6570\uFF0C\u9700\u8981\u4EBA\u5DE5\u786E\u8BA4\u6240\u6709\u8FD4\u56DE\u5206\u652F");
+        if (ts[i].value === "return" && !ts[i].literal) {
+          found = i + 1;
+          break;
+        }
+        if (!ts[i].literal && ["{", "[", "("].includes(ts[i].value)) i = closeAt(ts, i);
+      }
+      if (found < 0 || ts[found]?.value !== "{") throw new Error("\u672A\u627E\u5230\u552F\u4E00\u7684\u76F4\u63A5 return \u914D\u7F6E\u5BF9\u8C61");
+      obj = found;
+      const rest = ts.slice(closeAt(ts, obj) + 1, bodyEnd).map((t) => t.value).join("");
+      if (!["", ";"].includes(rest)) throw new Error("return \u540E\u4ECD\u6709\u8BED\u53E5\uFF0C\u914D\u7F6E\u5DE5\u5382\u9700\u4EBA\u5DE5\u786E\u8BA4");
+    }
+  }
+  const end = closeAt(ts, obj);
+  if (expressionEnd < 0) expressionEnd = end;
+  if (outerEnd < 0) outerEnd = end;
+  else if (outerEnd !== expressionEnd && expressionEnd + 1 !== outerEnd) throw new Error("\u914D\u7F6E\u5BF9\u8C61\u540E\u6709\u989D\u5916\u8868\u8FBE\u5F0F\u6216\u53C2\u6570\uFF0C\u8BF7\u624B\u52A8\u5408\u5E76");
+  const tail = ts.slice(outerEnd + 1).map((t) => t.value).join("");
+  if (!["", ";"].includes(tail)) throw new Error("\u914D\u7F6E\u540E\u5B58\u5728\u5305\u88C5\u6216\u9644\u52A0\u8BED\u53E5\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76");
+  let plugins = -1, pluginsEnd = -1;
+  for (let i = obj + 1; i < end; ) {
+    if (ts[i].value === ",") {
+      i++;
+      continue;
+    }
+    const key = ts[i];
+    if (key.value === "...") throw new Error("\u9876\u5C42 spread \u53EF\u80FD\u8986\u76D6 plugins\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76");
+    if (ts[i + 1]?.value !== ":") {
+      if (!key.literal && /^[A-Za-z_$][\w$]*$/.test(key.value) && [",", "}"].includes(ts[i + 1]?.value)) {
+        if (key.value === "plugins") throw new Error("plugins \u4F7F\u7528\u7B80\u5199\u53D8\u91CF\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76");
+        i++;
+        continue;
+      }
+      throw new Error("\u9876\u5C42\u8BA1\u7B97\u5C5E\u6027\u6216\u65B9\u6CD5\u9700\u4EBA\u5DE5\u786E\u8BA4");
+    }
+    if (key.value === "plugins") {
+      if (plugins >= 0) throw new Error("\u5B58\u5728\u91CD\u590D plugins \u5C5E\u6027");
+      plugins = i + 2;
+    }
+    i += 2;
+    while (i < end && ts[i].value !== ",") {
+      if (!ts[i].literal && ["[", "{", "("].includes(ts[i].value)) i = closeAt(ts, i) + 1;
+      else i++;
+    }
+    if (key.value === "plugins") pluginsEnd = i;
+  }
+  const edit = new MagicString(source);
+  if (plugins >= 0) {
+    if (ts[plugins]?.value === "[") {
+      const last = closeAt(ts, plugins);
+      const separator = last === plugins + 1 || ts[last - 1].value === "," ? "" : ",";
+      edit.appendLeft(ts[last].start, separator + "\n    fulgurjsFederation(fulgurjsConfig),\n  ");
+    } else {
+      const finish = ts[pluginsEnd].start;
+      edit.appendLeft(ts[plugins].start, "[");
+      edit.appendLeft(finish, ", fulgurjsFederation(fulgurjsConfig)]");
+    }
+  } else edit.appendLeft(ts[obj].end, "\n  plugins: [fulgurjsFederation(fulgurjsConfig)],");
+  edit.prepend(`${OWNER}
+import fulgurjsFederation from '@fulgurjs/federation'
+import fulgurjsConfig from './fulgurjs.config'
+`);
+  const result = edit.toString();
+  await validateSource(file, result);
+  return result;
+}
+async function applicationFromEntry(file, source, framework) {
+  await validateSource(file, source);
+  await init;
+  const header2 = source.match(/^\s*(?:(?:\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)\s*)*/)?.[0] ?? "";
+  let body = source.slice(header2.length);
+  const declarations = [];
+  const importStatements = [];
+  while (true) {
+    const comment = body.match(/^\s*(?:\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)/);
+    if (comment) {
+      declarations.push(comment[0]);
+      body = body.slice(comment[0].length);
+      continue;
+    }
+    const match = body.match(/^\s*(import\s+(?:(?:type\s+)?[\w*$ {},\r\n]+?\s+from\s+)?(['"])([^'"\n]+)\2\s*;?)/);
+    if (!match) break;
+    const statement = match[1];
+    const [items] = parse(statement);
+    if (items.length !== 1 || items[0].d !== -1) throw new Error("\u5165\u53E3 import \u7ED3\u6784\u9700\u4EBA\u5DE5\u6838\u5B9E");
+    const spec = items[0].n;
+    if (/router|pinia|vuex|redux|zustand/i.test(spec)) throw new Error("\u5165\u53E3\u4F9D\u8D56\u4E1A\u52A1\u8DEF\u7531\u6216\u72B6\u6001\uFF1B\u6309 existing-apps \u6307\u5357\u5C06\u5B83\u4EEC\u5728\u5DE5\u5382\u5185\u6309\u5B9E\u4F8B\u521B\u5EFA\uFF0C\u4E0D\u81EA\u52A8\u6539\u5199");
+    importStatements.push({ spec, code: statement });
+    if (spec !== "react-dom/client") declarations.push(statement);
+    body = body.slice(match[0].length);
+  }
+  body = body.trim();
+  let expression, target;
+  if (framework === "vue") {
+    const named = declarations.join("\n").match(/import\s*\{\s*createApp\s*\}\s*from\s*['"]vue['"]/);
+    const direct = body.match(/^createApp\(\s*([A-Za-z_$][\w$]*)\s*\)\.mount\(\s*(['"])(#[\w-]+)\2\s*\)\s*;?$/);
+    const variable = body.match(/^const\s+(\w+)\s*=\s*createApp\(\s*([A-Za-z_$][\w$]*)\s*\)\s*;?\s*\1\.mount\(\s*(['"])(#[\w-]+)\3\s*\)\s*;?$/);
+    if (!named || !direct && !variable) throw new Error("\u4EC5\u81EA\u52A8\u63D0\u53D6\u6700\u5C0F createApp(App).mount \u5165\u53E3\uFF1B\u63D2\u4EF6\u3001\u5B88\u536B\u4E0E\u5F02\u6B65\u4E1A\u52A1\u88C5\u914D\u8BF7\u6309\u6307\u5357\u8FC1\u5165 defineApplication \u5DE5\u5382");
+    expression = `createApp(${direct?.[1] ?? variable[2]})`;
+    target = direct?.[3] ?? variable[4];
+  } else {
+    const named = importStatements.find((item) => item.spec === "react-dom/client");
+    if (!named || !/^import\s*\{\s*createRoot\s*\}\s*from/.test(named.code)) throw new Error("\u4EC5\u81EA\u52A8\u63D0\u53D6\u5177\u540D createRoot \u5BFC\u5165\u7684\u5165\u53E3\uFF1B\u5176\u4ED6\u542F\u52A8\u5F62\u5F0F\u8BF7\u6309\u6307\u5357\u8FC1\u79FB");
+    const direct = body.match(/^createRoot\(\s*document\.getElementById\(\s*(['"])([\w-]+)\1\s*\)!?\s*\)\.render\(([\s\S]+)\)\s*;?$/);
+    if (!direct) throw new Error("\u4EC5\u81EA\u52A8\u63D0\u53D6 createRoot(document.getElementById(...)).render(...)\uFF1B\u5176\u4F59\u5165\u53E3\u9700\u4EBA\u5DE5\u5408\u5E76");
+    expression = direct[3].trim().replace(/,\s*$/, "");
+    target = "#" + direct[2];
+    if (!expression.startsWith("<") || !expression.endsWith(">")) throw new Error("React \u6839\u6E32\u67D3\u4E0D\u662F\u660E\u786E JSX \u8868\u8FBE\u5F0F\uFF0C\u8BF7\u4EBA\u5DE5\u5408\u5E76");
+  }
+  const application = `${OWNER}
+/** \u72EC\u7ACB\u542F\u52A8\u4E0E\u6865\u63A5\u5171\u7528\u5DE5\u5382\uFF1B\u6BCF\u6B21\u6302\u8F7D\u521B\u5EFA\u81EA\u5DF1\u7684\u5B9E\u4F8B\u3002\u4E1A\u52A1\u63D2\u4EF6\u5728\u5DE5\u5382\u5185\u88C5\u914D\uFF0C\u4E0D\u5728\u6A21\u5757\u9876\u5C42\u6302\u8F7D\u3002 */
+${declarations.join("\n")}
+import { defineApplication } from '@fulgurjs/federation/${framework}'
+
+export default defineApplication(() => ${expression})
+`;
+  const main2 = `${OWNER}
+${header2}// \u72EC\u7ACB\u5165\u53E3\u4F7F\u7528\u540C\u4E00\u4EFD\u88C5\u914D\uFF1B\u5BBF\u4E3B\u76F4\u63A5\u52A0\u8F7D application \u7684\u9ED8\u8BA4\u5BFC\u51FA\uFF0C\u4E0D\u590D\u5236\u542F\u52A8\u903B\u8F91\u3002
+import application from './application'
+void application.start(${JSON.stringify(target)}).catch(console.error)
+`;
+  await validateSource(framework === "react" ? "application.tsx" : "application.ts", application);
+  return { application, main: main2 };
+}
+async function planIntegration(input) {
+  const root = fs2.realpathSync(path2.resolve(input.cwd));
+  const pkgFile = path2.join(root, "package.json");
+  const pkg = JSON.parse(fs2.readFileSync(pkgFile, "utf8"));
+  const framework = input.framework ?? detectFrameworkFromPackageJson(pkg);
+  const plan = { root, framework, role: input.role ?? "dual", kind: input.kind ?? "component", edits: [], tasks: [], evidence: [], commands: [] };
+  const task = (file, message, blocking = true) => plan.tasks.push({ file, message, blocking });
+  const read = (file) => {
+    safe(file);
+    return fs2.existsSync(path2.join(root, file)) ? fs2.readFileSync(path2.join(root, file), "utf8") : null;
+  };
+  const safe = (file) => {
+    const absolute = path2.resolve(root, file), relative = path2.relative(root, absolute);
+    if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) throw new Error(`\u8DEF\u5F84\u5FC5\u987B\u5728\u5F53\u524D\u5E94\u7528\u5185\uFF1A${file}`);
+    let current = root;
+    for (const part of relative.split(path2.sep)) {
+      current = path2.join(current, part);
+      rejectSymlink(current, file);
+    }
+    return relative.split(path2.sep).join("/");
+  };
+  const add = (file, after, reason, replace = false) => {
+    file = safe(file);
+    const before = read(file);
+    if (before !== after) {
+      if (before !== null && !replace) task(file, "\u5DF2\u6709\u4E0D\u540C\u5185\u5BB9\uFF0C\u4FDD\u7559\u539F\u6587\u4EF6\uFF1B\u8BF7\u4EBA\u5DE5\u5408\u5E76\uFF0C\u4E0D\u8986\u76D6\u5DF2\u6709\u63A5\u5165\u6216\u4E1A\u52A1\u4FEE\u6539");
+      else plan.edits.push({ file, before, after, reason });
+    }
+  };
+  if (fs2.existsSync(path2.join(root, JOURNAL))) task(JOURNAL, "\u4E0A\u6B21\u5199\u5165\u88AB\u4E2D\u65AD\uFF1B\u5148\u8FD0\u884C fulgurjs init --rollback \u6062\u590D\uFF0C\u518D\u91CD\u65B0\u9884\u89C8");
+  if (!framework) {
+    task("package.json", "\u65E0\u6CD5\u552F\u4E00\u5224\u65AD Vue/React\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A --framework vue|react");
+    return plan;
+  }
+  plan.evidence.push(`\u6846\u67B6\uFF1A${framework}\uFF08${input.framework ? "\u663E\u5F0F\u9009\u62E9" : "package.json \u4F9D\u8D56"}\uFF09`, `\u573A\u666F\uFF1A${plan.kind}\uFF1B\u89D2\u8272\uFF1A${plan.role}`);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const manager = typeof pkg.packageManager === "string" && pkg.packageManager.startsWith("pnpm@") ? "pnpm" : fs2.existsSync(path2.join(root, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  if (!deps["@fulgurjs/federation"]) task("package.json", `\u5148\u8FD0\u884C ${manager === "pnpm" ? "pnpm add" : "npm install"} @fulgurjs/federation\uFF1B\u8BA1\u5212\u4E0D\u4F1A\u81EA\u884C\u5B89\u88C5\u6216\u6539\u9501\u6587\u4EF6`, false);
+  const viteFiles = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"].filter((f) => read(f) !== null);
+  const viteFile = viteFiles.length === 1 ? viteFiles[0] : null;
+  if (!viteFile) task("vite.config", "\u672A\u627E\u5230\u552F\u4E00 Vite \u914D\u7F6E\uFF08\u652F\u6301 ts/mts/js/mjs\uFF09\uFF1B\u660E\u786E\u5B9E\u9645\u914D\u7F6E\u540E\u624B\u52A8\u6CE8\u518C federation(fulgurjsConfig)");
+  else {
+    try {
+      const code = read(viteFile);
+      if (code.startsWith(OWNER)) plan.evidence.push(`${viteFile}\uFF1A\u5DF2\u6709\u672C\u5DE5\u5177\u63A5\u7EBF\uFF0C\u4FDD\u7559\u539F\u6587\u4EF6\uFF1B\u518D\u8FD0\u884C doctor \u6838\u67E5`);
+      else add(viteFile, await wireVite(viteFile, code), "\u5728\u5B9E\u9645\u9876\u5C42 plugins \u6570\u7EC4\u6CE8\u518C\u63D2\u4EF6\uFF0C\u4FDD\u7559\u539F\u6709\u914D\u7F6E\u4E0E\u6CE8\u91CA", true);
+    } catch (error) {
+      task(viteFile, `${error.message}\u3002\u624B\u52A8\u63A5\u5165\u5757\uFF1Aimport federation from '@fulgurjs/federation'; import fulgurjsConfig from './fulgurjs.config'; plugins: [...\u539F\u63D2\u4EF6, federation(fulgurjsConfig)]`);
+    }
+  }
+  const appExt = framework === "react" ? "tsx" : "ts";
+  let exposes = input.exposes ?? {};
+  if (plan.kind === "app" && plan.role !== "consumer") {
+    const appFile = `src/application.${appExt}`;
+    const existing = read(appFile);
+    if (existing) {
+      if (!existing.startsWith(OWNER) && !/export\s+default\s+defineApplication(?:<[^;]+?>)?\s*\(/.test(existing)) task(appFile, "\u5DF2\u6709\u5E94\u7528\u88C5\u914D\u6587\u4EF6\uFF0C\u65E0\u6CD5\u786E\u8BA4\u9ED8\u8BA4\u5BFC\u51FA\u7684 defineApplication\uFF1B\u4FDD\u7559\u539F\u4EE3\u7801\uFF0C\u5148\u6309\u6307\u5357\u6838\u5B9E\u88C5\u914D");
+      else {
+        exposes = { ...exposes, "./bridge": "./" + appFile };
+        plan.evidence.push(`${appFile}\uFF1A\u4FDD\u7559\u5DF2\u751F\u6210\u88C5\u914D`);
+      }
+    } else {
+      const candidates = input.entry ? [safe(input.entry)] : [`src/main.${framework === "react" ? "tsx" : "ts"}`, `src/main.${framework === "react" ? "jsx" : "js"}`].filter((f) => read(f) !== null);
+      if (candidates.length !== 1 || read(candidates[0]) === null) task("src/main", "\u65E0\u6CD5\u5B9A\u4F4D\u552F\u4E00\u542F\u52A8\u5165\u53E3\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A --entry <\u5F53\u524D\u5E94\u7528\u5185\u8DEF\u5F84>");
+      else {
+        try {
+          const entry = candidates[0], result = await applicationFromEntry(entry, read(entry), framework);
+          add(appFile, result.application, "\u5C06\u53EF\u8BC1\u660E\u7684\u6700\u5C0F\u542F\u52A8\u903B\u8F91\u63D0\u53D6\u4E3A\u72EC\u7ACB/\u6865\u63A5\u5171\u7528\u5DE5\u5382");
+          add(entry, result.main, "\u72EC\u7ACB\u5165\u53E3\u6539\u4E3A application.start\uFF1B\u6302\u8F7D\u8D23\u4EFB\u4EA4\u7ED9\u63D2\u4EF6", true);
+          exposes = { ...exposes, "./bridge": "./" + appFile };
+        } catch (error) {
+          task(candidates[0], `${error.message}\u3002\u53C2\u8003 docs/zh/guide/existing-apps.md\uFF1B\u6865\u63A5\u8DEF\u7531\u5FC5\u987B\u4F7F\u7528\u53D7\u63A7 memory\uFF0C\u72EC\u7ACB\u6A21\u5F0F\u7EE7\u7EED web history\u3002`);
+        }
+      }
+    }
+  }
+  const remoteEntries = Object.entries(input.remotes ?? {});
+  if (plan.role === "provider" && remoteEntries.length) task("\u89D2\u8272", "\u63D0\u4F9B/\u6D88\u8D39\u540C\u65F6\u5B58\u5728\u8BF7\u4F7F\u7528 --role dual\uFF1Bprovider \u4E0D\u63A5\u53D7 --remote");
+  if (plan.role === "consumer" && Object.keys(exposes).length) task("\u89D2\u8272", "\u63D0\u4F9B/\u6D88\u8D39\u540C\u65F6\u5B58\u5728\u8BF7\u4F7F\u7528 --role dual\uFF1Bconsumer \u4E0D\u63A5\u53D7 --expose");
+  for (const [key, url] of remoteEntries) {
+    let validURL = false;
+    try {
+      const parsed = new URL(url);
+      validURL = ["http:", "https:"].includes(parsed.protocol) && !!parsed.hostname;
+    } catch {
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(key) || !validURL) task("remotes", `--remote \u5FC5\u987B\u4E3A \u5BB9\u5668\u540D=http(s)://\u5F00\u53D1\u5730\u5740\uFF0C\u5B9E\u9645\uFF1A${key}=${url}`);
+  }
+  for (const [key, file] of Object.entries(exposes)) {
+    if (!key.startsWith("./") || !file.startsWith("./")) {
+      task("exposes", `\u66B4\u9732\u952E\u4E0E\u8DEF\u5F84\u987B\u4EE5 ./ \u5F00\u5934\uFF1A${key}=${file}`);
+      continue;
+    }
+    const relative = safe(file);
+    if (read(relative) === null && !plan.edits.some((edit) => edit.file === relative)) task(relative, "expose \u6307\u5411\u4E0D\u5B58\u5728\u7684\u6587\u4EF6\uFF1B\u9009\u62E9\u771F\u5B9E\u6A21\u5757\u6216\u7EC4\u4EF6\uFF0C\u4E0D\u751F\u6210\u5047\u4E1A\u52A1\u7EC4\u4EF6");
+  }
+  const configFile = "fulgurjs.config.ts";
+  const config = read(configFile);
+  if (!config) {
+    if (plan.role !== "consumer" && !Object.keys(exposes).length) task(configFile, "\u63D0\u4F9B\u65B9\u5FC5\u987B\u9009\u62E9\u771F\u5B9E\u66B4\u9732\u6587\u4EF6\uFF1A--expose ./Button=./src/components/Button.vue\uFF1B\u666E\u901A\u51FD\u6570\u4E5F\u53EF\u76F4\u63A5\u66B4\u9732");
+    if (plan.role !== "provider" && !remoteEntries.length) task(configFile, "\u6D88\u8D39\u65B9\u9700\u8981\u771F\u5B9E\u8FDC\u7A0B\u5F00\u53D1\u5730\u5740\uFF1A--remote remote-a=http://localhost:5174/remote-a\uFF1B\u4E0D\u4F1A\u731C\u7AEF\u53E3");
+    const name = input.name ?? (typeof pkg.name === "string" ? pkg.name.replace(/^@/, "").replace(/[^A-Za-z0-9_-]/g, "-") : "");
+    if (!name || !/^[A-Za-z0-9_-]+$/.test(name)) task(configFile, "\u8BF7\u7528 --name \u6307\u5B9A\u540C\u4E00\u9875\u9762\u5185\u552F\u4E00\u7684\u5BB9\u5668\u540D\uFF08\u5B57\u6BCD/\u6570\u5B57/\u4E0B\u5212\u7EBF/\u8FDE\u5B57\u7B26\uFF09");
+    const shared = framework === "vue" ? { vue: { singleton: true } } : { react: { singleton: true }, "react-dom": { singleton: true } };
+    const body = { name, ...Object.keys(exposes).length ? { exposes } : {}, ...remoteEntries.length ? { remotes: Object.fromEntries(remoteEntries.map(([key, url]) => [key, { dev: url, prod: "/" + key }])) } : {}, shared };
+    add(configFile, `${OWNER}
+/** \u63D0\u4F9B/\u6D88\u8D39\u58F0\u660E\uFF1B\u5F00\u53D1\u5730\u5740\u6765\u81EA\u663E\u5F0F\u8F93\u5165\uFF0C\u751F\u4EA7\u8DEF\u5F84\u9700\u6309\u5B9E\u9645\u90E8\u7F72\u6838\u5BF9\u3002 */
+import type { FederationOptions } from '@fulgurjs/federation'
+
+export default ${JSON.stringify(body, null, 2)} satisfies FederationOptions
+`, "\u751F\u6210\u4F7F\u7528\u771F\u5B9E\u6587\u4EF6\u548C\u663E\u5F0F\u5730\u5740\u7684\u914D\u7F6E\uFF0C\u4E0D\u589E\u52A0\u65E0\u5173 setup/\u83DC\u5355/\u4F1A\u8BDD\u6587\u4EF6");
+  } else {
+    plan.evidence.push(`${configFile} \u5DF2\u5B58\u5728\uFF0C\u4FDD\u7559\u6240\u6709\u8005\u914D\u7F6E\uFF0C\u4E0D\u6309\u547D\u4EE4\u53C2\u6570\u8986\u76D6`);
+    if (!config.startsWith(OWNER)) task(configFile, "\u5DF2\u6709\u914D\u7F6E\u9700\u624B\u52A8\u6838\u5BF9\u672C\u6B21 remotes/exposes\uFF0C\u6216\u53EA\u4F7F\u7528 init --config/doctor --config \u68C0\u67E5");
+  }
+  if (plan.kind === "app" && plan.role !== "provider") {
+    const remote = remoteEntries[0]?.[0];
+    if (remote) add(`src/fulgurjs/RemoteApplication.${framework === "react" ? "tsx" : "vue"}`, hostView(framework, remote), "\u751F\u6210\u53EF\u653E\u8FDB\u5DF2\u6709\u8DEF\u7531\u7684\u6302\u8F7D\u89C6\u56FE\uFF1B\u8DEF\u7531\u548C\u767B\u5F55\u4E0A\u4E0B\u6587\u7531\u5E94\u7528\u660E\u786E\u51B3\u5B9A");
+    task("\u5BBF\u4E3B\u8DEF\u7531", "\u5C06 RemoteApplication \u89C6\u56FE\u52A0\u5165\u5DF2\u6709\u9875\u9762/\u8DEF\u7531\u3002\u542F\u7528 URL \u540C\u6B65\u65F6\uFF0C\u6309\u6307\u5357\u7ED1\u5B9A\u5BBF\u4E3B\u5BFC\u822A\u7AEF\u53E3\u4E0E\u4E00\u4E2A\u9759\u6001\u6302\u8F7D\u524D\u7F00\uFF1B\u4E0D\u91CD\u590D\u767B\u8BB0\u5B50\u5E94\u7528\u83DC\u5355\u3002", false);
+    task("\u4F1A\u8BDD\u4E0E\u4E1A\u52A1\u4E0A\u4E0B\u6587", "\u6709\u767B\u5F55\u9700\u6C42\u65F6\u660E\u786E token getter/sessionKey\u3001\u6743\u9650\u4E0E\u4E3B\u9898\u5F52\u5C5E\uFF1B\u6CA1\u6709\u9700\u6C42\u4E0D\u589E\u52A0\u6587\u4EF6\u3002\u5DE5\u5177\u4E0D\u731C\u51ED\u636E\uFF0C\u4E5F\u4E0D\u590D\u5236\u6574\u4E2A\u4E1A\u52A1 app \u7684\u72B6\u6001\u3002", false);
+  } else if (plan.role !== "provider") {
+    task("\u5DF2\u6709\u6D88\u8D39\u9875\u9762", "\u6A21\u5757\u7528 loadRemote\uFF1B\u540C\u6846\u67B6\u7EC4\u4EF6\u7528 remoteComponent\uFF0C\u5728\u5DF2\u6709\u89C6\u56FE\u6E32\u67D3\u5E76\u4F20\u771F\u5B9E props\uFF1B\u4E0D\u751F\u6210\u5E94\u7528\u5DE5\u5382\u3001\u83DC\u5355\u3001Provider \u6216\u4F1A\u8BDD\u6587\u4EF6\u3002", false);
+  }
+  if (plan.kind === "app") task("\u8DEF\u7531\u4E0E\u4E1A\u52A1\u88C5\u914D", "\u672C\u5DE5\u5177\u4EC5\u81EA\u52A8\u63D0\u53D6\u65E0 Router/store \u7684\u6700\u5C0F\u5165\u53E3\u3002\u5DF2\u6709\u590D\u6742\u5E94\u7528\u6309\u6307\u5357\u8FD4\u56DE\u6BCF\u6B21\u65B0\u5EFA\u7684 app/router \u6216 element/dispose\uFF1B\u786E\u4FDD memory \u8DEF\u7531\u3001\u5B88\u536B\u3001\u4E3B\u9898\u548C\u6743\u9650\u5C31\u7EEA\u540E\u518D\u6302\u8F7D\u3002", false);
+  plan.commands.push("npx fulgurjs doctor --config ./fulgurjs.config.ts", "\u8FD0\u884C\u672C\u9879\u76EE\u6709\u6548\u914D\u7F6E\u4E0B\u7684\u7C7B\u578B\u68C0\u67E5\u4E0E\u6784\u5EFA\uFF0C\u518D\u9A8C\u8BC1\u771F\u5B9E\u6302\u8F7D\u3001\u4EA4\u4E92\u3001\u91CD\u8FDB/\u5378\u8F7D");
+  return plan;
+}
+function hostView(framework, remote) {
+  if (framework === "vue") return `${OWNER.replace("//", "<!--")} -->
+<script setup lang="ts">
+// \u628A\u6B64\u89C6\u56FE\u653E\u8FDB\u5DF2\u6709\u9875\u9762\u3002\u65E0\u767B\u5F55/URL \u540C\u6B65\u9700\u6C42\u65E0\u9700\u589E\u52A0\u989D\u5916\u914D\u7F6E\u3002
+import { createVueBridgeApp } from '@fulgurjs/federation/vue'
+const RemoteApplication = createVueBridgeApp('${remote}/bridge')
+</script>
+<template><RemoteApplication /></template>
+`;
+  return `${OWNER}
+// \u653E\u8FDB\u5DF2\u6709\u9875\u9762\uFF1B\u9700\u8981 URL \u540C\u6B65/\u767B\u5F55\u65F6\u663E\u5F0F\u4F20 routing/sessionKey/getContext\uFF0C\u4E0D\u731C\u5BBF\u4E3B\u5B9E\u73B0\u3002
+import { createReactBridgeApp } from '@fulgurjs/federation/react'
+export default createReactBridgeApp('${remote}/bridge')
+`;
+}
+function targetOf(root, relative) {
+  const absolute = path2.resolve(root, relative);
+  if (!absolute.startsWith(root + path2.sep)) throw new Error("\u8BA1\u5212\u6587\u4EF6\u8D8A\u8FC7\u5E94\u7528\u76EE\u5F55");
+  let cursor = root;
+  for (const part of path2.relative(root, absolute).split(path2.sep)) {
+    cursor = path2.join(cursor, part);
+    rejectSymlink(cursor, relative);
+  }
+  return absolute;
+}
+function currentSource(file) {
+  return fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : null;
+}
+function replaceSource(file, content, exclusive = false) {
+  const temp = file + `.fulgurjs-${process.pid}.tmp`;
+  let created = false;
+  try {
+    fs2.writeFileSync(temp, content, { flag: "wx", mode: fs2.existsSync(file) ? fs2.statSync(file).mode : 420 });
+    created = true;
+    if (exclusive) {
+      fs2.linkSync(temp, file);
+      fs2.unlinkSync(temp);
+    } else fs2.renameSync(temp, file);
+  } finally {
+    if (created && fs2.existsSync(temp)) fs2.unlinkSync(temp);
+  }
+}
+function applyIntegration(plan) {
+  if (plan.tasks.some((t) => t.blocking)) throw new Error("\u8BA1\u5212\u5305\u542B\u963B\u65AD\u9879\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u6587\u4EF6\uFF1B\u5148\u5904\u7406\u6240\u5217\u6587\u4EF6\u518D\u9884\u89C8\u3002");
+  const root = fs2.realpathSync(plan.root);
+  for (const edit of plan.edits) {
+    const target = targetOf(root, edit.file);
+    if (currentSource(target) !== edit.before) throw new Error(`\u9884\u89C8\u540E\u6587\u4EF6\u5DF2\u53D8\u5316\uFF1A${edit.file}\uFF1B\u8BF7\u91CD\u65B0\u751F\u6210\u8BA1\u5212\u3002`);
+    if (fs2.existsSync(target + `.fulgurjs-${process.pid}.tmp`)) throw new Error(`\u4E34\u65F6\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u4FDD\u7559\u5E76\u8BF7\u5148\u6838\u67E5\uFF1A${edit.file}`);
+  }
+  if (!plan.edits.length) return;
+  const journal = targetOf(root, JOURNAL);
+  const directories = /* @__PURE__ */ new Set();
+  for (const edit of plan.edits) {
+    let dir = path2.dirname(targetOf(root, edit.file));
+    while (dir !== root && !fs2.existsSync(dir)) {
+      directories.add(path2.relative(root, dir));
+      dir = path2.dirname(dir);
+    }
+  }
+  fs2.writeFileSync(journal, JSON.stringify({ root, pid: process.pid, directories: [...directories], edits: plan.edits }), { flag: "wx", mode: 384 });
+  try {
+    for (const edit of plan.edits) {
+      const file = targetOf(root, edit.file);
+      if (currentSource(file) !== edit.before) throw new Error(`\u5199\u5165\u524D\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${edit.file}`);
+      fs2.mkdirSync(path2.dirname(file), { recursive: true });
+      replaceSource(file, edit.after, edit.before === null);
+    }
+    fs2.unlinkSync(journal);
+  } catch (error) {
+    try {
+      rollbackIntegration(root);
+    } catch {
+    }
+    throw error;
+  }
+}
+function rollbackIntegration(cwd) {
+  const root = fs2.realpathSync(cwd), journal = targetOf(root, JOURNAL);
+  const saved = JSON.parse(fs2.readFileSync(journal, "utf8"));
+  if (saved.root !== root || !Array.isArray(saved.edits)) throw new Error("\u6062\u590D\u8BB0\u5F55\u4E0E\u5F53\u524D\u76EE\u5F55\u4E0D\u4E00\u81F4\uFF0C\u62D2\u7EDD\u81EA\u52A8\u56DE\u9000");
+  for (const edit of saved.edits) {
+    if (typeof edit.file !== "string" || typeof edit.after !== "string" || edit.before !== null && typeof edit.before !== "string") throw new Error("\u6062\u590D\u8BB0\u5F55\u683C\u5F0F\u65E0\u6548");
+    const value = currentSource(targetOf(root, edit.file));
+    if (value !== edit.before && value !== edit.after) throw new Error(`\u6587\u4EF6\u6709\u540E\u7EED\u7F16\u8F91\uFF0C\u4FDD\u7559\u5185\u5BB9\u548C\u6062\u590D\u8BB0\u5F55\uFF1A${edit.file}\uFF1B\u8BF7\u4EBA\u5DE5\u5408\u5E76\u540E\u518D\u6062\u590D\u3002`);
+  }
+  for (const edit of [...saved.edits].reverse()) {
+    const file = targetOf(root, edit.file);
+    if (currentSource(file) !== edit.before) {
+      if (edit.before === null) fs2.unlinkSync(file);
+      else replaceSource(file, edit.before);
+    }
+    if (Number.isSafeInteger(saved.pid) && saved.pid > 0) {
+      const temp = file + `.fulgurjs-${saved.pid}.tmp`;
+      if (fs2.existsSync(temp)) fs2.unlinkSync(temp);
+    }
+  }
+  for (const dir of [...saved.directories ?? []].sort((a, b) => b.length - a.length)) {
+    const directory = targetOf(root, dir);
+    if (fs2.existsSync(directory) && fs2.readdirSync(directory).length === 0) fs2.rmdirSync(directory);
+  }
+  fs2.unlinkSync(journal);
+}
+function formatIntegrationPlan(plan) {
+  const lines = ["[fulgurjs:init] \u63A5\u5165\u9884\u89C8\uFF08\u9ED8\u8BA4\u4E0D\u5199\u5165\u3001\u4E0D\u5B89\u88C5\u4F9D\u8D56\u3001\u4E0D\u6267\u884C\u4E1A\u52A1\u4EE3\u7801\uFF09", ...plan.evidence];
+  for (const edit of plan.edits) {
+    lines.push(`
+--- ${edit.before === null ? "/dev/null" : edit.file}
++++ ${edit.file}
+\u539F\u56E0\uFF1A${edit.reason}`);
+    if (edit.before !== null) lines.push(...edit.before.split("\n").map((line) => "- " + line));
+    lines.push(...edit.after.split("\n").map((line) => "+ " + line));
+  }
+  lines.push("\n\u5F85\u529E\uFF08\u4E0D\u7B49\u4E8E\u6D4F\u89C8\u5668\u5DF2\u9A8C\u6536\uFF09\uFF1A", ...plan.tasks.map((t) => `${t.blocking ? "\u963B\u65AD" : "\u4EBA\u5DE5\u63A5\u7EBF/\u6838\u67E5"} ${t.file}\uFF1A${t.message}`), "\n\u540E\u7EED\u547D\u4EE4\uFF1A", ...plan.commands);
+  return lines.join("\n");
+}
+var requireHere, OWNER, JOURNAL;
+var init_init_plan = __esm({
+  "src/init-plan.ts"() {
+    "use strict";
+    init_lexer();
+    init_magic_string_es();
+    init_init();
+    requireHere = createRequire2(import.meta.url);
+    OWNER = "// @fulgurjs generated: existing-app integration";
+    JOURNAL = ".fulgurjs-init-pending.json";
+  }
+});
+
 // src/create.ts
 var create_exports = {};
 __export(create_exports, {
@@ -664,16 +2345,16 @@ __export(create_exports, {
   templateEnginesNode: () => templateEnginesNode,
   validateTemplateDir: () => validateTemplateDir
 });
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 function packageRootOf(moduleUrl) {
   return fileURLToPath(new URL("..", moduleUrl));
 }
 function resolveTemplatesRoot(moduleUrl) {
-  const root = path2.join(packageRootOf(moduleUrl), "examples", "templates");
-  if (!fs2.existsSync(root)) {
+  const root = path3.join(packageRootOf(moduleUrl), "examples", "templates");
+  if (!fs3.existsSync(root)) {
     throw new Error(
       "[fulgurjs:create] \u5F53\u524D\u5B89\u88C5\u7F3A\u5C11\u6A21\u677F\u8D44\u4EA7\uFF08examples/templates\uFF09\u3002\n  \u6839\u56E0\uFF1A\u6A21\u677F\u7531 npm \u6B63\u5F0F\u5305\u9644\u5E26\uFF1B\u4ECE\u4ED3\u5E93\u6E90\u7801\u76F4\u63A5\u8FD0\u884C CLI \u65F6\u8BE5\u76EE\u5F55\u53EA\u5728 build \u540E\u751F\u6210\u3002\n  \u4FEE\u6CD5\uFF1A\u7528 npm \u6B63\u5F0F\u5305\u8FD0\u884C\uFF08npx @fulgurjs/federation create\uFF09\uFF0C\u6216\u5728\u63D2\u4EF6\u4ED3\u5E93\u6267\u884C npm --prefix packages/plugin run build \u540E\u91CD\u8BD5"
     );
@@ -688,14 +2369,14 @@ function isExcluded(name) {
 function scanTemplateConflicts(from, to) {
   const conflicts = [];
   const walk = (srcDir, relDir) => {
-    for (const entry of fs2.readdirSync(srcDir, { withFileTypes: true })) {
+    for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
       if (isExcluded(entry.name)) continue;
       const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
-      const src = path2.join(srcDir, entry.name);
-      const dest = path2.join(to, rel);
+      const src = path3.join(srcDir, entry.name);
+      const dest = path3.join(to, rel);
       let destStat;
       try {
-        destStat = fs2.lstatSync(dest);
+        destStat = fs3.lstatSync(dest);
       } catch {
       }
       if (!destStat) {
@@ -722,12 +2403,12 @@ function copyMissingFiles(from, to, conflicts) {
   const blocked = new Set(conflicts.map((c) => c.rel));
   const outcome = { copied: [], skipped: [] };
   const walk = (srcDir, relDir) => {
-    fs2.mkdirSync(to, { recursive: true });
-    for (const entry of fs2.readdirSync(srcDir, { withFileTypes: true })) {
+    fs3.mkdirSync(to, { recursive: true });
+    for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
       if (isExcluded(entry.name)) continue;
       const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
-      const src = path2.join(srcDir, entry.name);
-      const dest = path2.join(to, rel);
+      const src = path3.join(srcDir, entry.name);
+      const dest = path3.join(to, rel);
       if (blocked.has(rel)) {
         outcome.skipped.push({ rel, reason: conflicts.find((c) => c.rel === rel)?.reason ?? "\u540C\u540D\u51B2\u7A81" });
         continue;
@@ -736,8 +2417,8 @@ function copyMissingFiles(from, to, conflicts) {
         walk(src, rel);
         continue;
       }
-      fs2.mkdirSync(path2.dirname(dest), { recursive: true });
-      fs2.copyFileSync(src, dest);
+      fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+      fs3.copyFileSync(src, dest);
       outcome.copied.push(rel);
     }
   };
@@ -757,11 +2438,11 @@ function copyTemplate(from, to) {
 }
 function validateTemplateDir(dir) {
   const required = ["package.json", "pnpm-workspace.yaml", "pnpm-lock.yaml", "scripts/dev.mjs", "scripts/dev.config.json"];
-  return required.filter((f) => !fs2.existsSync(path2.join(dir, f)));
+  return required.filter((f) => !fs3.existsSync(path3.join(dir, f)));
 }
 function readDevConfig(templateDir) {
-  const file = path2.join(templateDir, "scripts", "dev.config.json");
-  const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+  const file = path3.join(templateDir, "scripts", "dev.config.json");
+  const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
   if (!Array.isArray(parsed.apps) || parsed.apps.length === 0) {
     throw new Error(`[fulgurjs:create] ${file} \u7F3A\u5C11 apps \u6570\u7EC4`);
   }
@@ -775,7 +2456,7 @@ function readDevConfig(templateDir) {
 function pluginVersionOf(templateDir, apps) {
   for (const app of apps) {
     try {
-      const pkg = JSON.parse(fs2.readFileSync(path2.join(templateDir, app.dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(fs3.readFileSync(path3.join(templateDir, app.dir, "package.json"), "utf8"));
       const version = pkg.dependencies?.["@fulgurjs/federation"];
       if (version) return version;
     } catch {
@@ -864,19 +2545,19 @@ async function createProject(opts, io) {
 \u4FEE\u6CD5\uFF1Afulgurjs create --list \u67E5\u770B\u8BF4\u660E\uFF0C\u6216 fulgurjs create <\u6A21\u677F\u540D> --dir <\u76EE\u6807\u76EE\u5F55>`
     );
   }
-  const templateDir = path2.join(opts.templatesRoot, templateName);
-  if (!fs2.existsSync(path2.join(templateDir, "package.json"))) {
+  const templateDir = path3.join(opts.templatesRoot, templateName);
+  if (!fs3.existsSync(path3.join(templateDir, "package.json"))) {
     throw new Error(`[fulgurjs:create] \u5305\u5185\u6A21\u677F\u4E0D\u5B8C\u6574\uFF1A${templateDir} \u7F3A\u5C11 package.json`);
   }
-  const target = path2.resolve(opts.cwd, opts.dir ?? templateName);
-  if (fs2.existsSync(target) && !fs2.statSync(target).isDirectory()) {
+  const target = path3.resolve(opts.cwd, opts.dir ?? templateName);
+  if (fs3.existsSync(target) && !fs3.statSync(target).isDirectory()) {
     throw new Error(
       `[fulgurjs:create] \u76EE\u6807\u8DEF\u5F84\u5DF2\u5B58\u5728\u4E14\u662F\u6587\u4EF6\uFF0C\u65E0\u6CD5\u4F5C\u4E3A\u5DE5\u7A0B\u76EE\u5F55\uFF1A${target}
   \u4FEE\u6CD5\uFF1A\u6362\u4E00\u4E2A\u76EE\u5F55\uFF08--dir\uFF09\uFF0C\u6216\u5148\u79FB\u8D70\u8BE5\u6587\u4EF6`
     );
   }
-  if (fs2.existsSync(target)) {
-    const existing = fs2.readdirSync(target);
+  if (fs3.existsSync(target)) {
+    const existing = fs3.readdirSync(target);
     if (existing.length > 0 && !opts.force) {
       throw new Error(
         `[fulgurjs:create] \u76EE\u6807\u76EE\u5F55\u975E\u7A7A\uFF0C\u62D2\u7EDD\u8986\u76D6\uFF1A${target}
@@ -903,7 +2584,7 @@ async function createProject(opts, io) {
   }
   let outcome;
   try {
-    if (fs2.existsSync(target) && fs2.readdirSync(target).length > 0) {
+    if (fs3.existsSync(target) && fs3.readdirSync(target).length > 0) {
       const conflicts = scanTemplateConflicts(templateDir, target);
       io.log(
         `[fulgurjs:create] --force\uFF1A\u5411\u975E\u7A7A\u76EE\u5F55 ${target} \u590D\u5236\uFF08\u53EA\u8865\u7F3A\u5931\u6587\u4EF6\uFF0C\u4E0D\u6539\u5199\u5DF2\u6709\u5185\u5BB9\uFF1B\u9884\u68C0\u5230 ${conflicts.length} \u4E2A\u540C\u540D\u51B2\u7A81\u5C06\u4FDD\u7559\u4F60\u7684\u7248\u672C\uFF09`
@@ -959,7 +2640,7 @@ async function createProject(opts, io) {
 }
 function templateEnginesNode(templateDir) {
   try {
-    const pkg = JSON.parse(fs2.readFileSync(path2.join(templateDir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs3.readFileSync(path3.join(templateDir, "package.json"), "utf8"));
     return pkg.engines?.node;
   } catch {
     return void 0;
@@ -1134,7 +2815,7 @@ __export(commands_exports, {
   manifestUrlForRemoteAddress: () => manifestUrlForRemoteAddress,
   stripRemoteNamePrefix: () => stripRemoteNamePrefix
 });
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 function mappingsOf(hp, deriveFallback) {
   const pages = hp.pages ?? [];
   const prefixes = Object.entries(hp.remotePrefixes ?? {}).sort((a, b) => b[0].length - a[0].length);
@@ -1289,7 +2970,7 @@ function formatExplain(r) {
 }
 function manifestFromFile(p) {
   try {
-    const parsed = parseManifest(JSON.parse(fs3.readFileSync(p, "utf8")));
+    const parsed = parseManifest(JSON.parse(fs4.readFileSync(p, "utf8")));
     if (parsed.manifest && !parsed.unsupportedVersion) return parsed.manifest;
   } catch {
   }
@@ -1458,7 +3139,7 @@ var RUNTIME_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    RUNTIME_VERSION = "6.9.3";
+    RUNTIME_VERSION = "6.10.1";
   }
 });
 
@@ -1482,9 +3163,9 @@ var init_dev_cors = __esm({
 });
 
 // src/options.ts
-import { createRequire as createRequire2 } from "node:module";
-import fs4 from "node:fs";
-import path3 from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+import fs5 from "node:fs";
+import path4 from "node:path";
 function joinUrl(base, file) {
   const b = base.endsWith("/") ? base : `${base}/`;
   return `${b}${file.replace(/^\//, "")}`;
@@ -1539,8 +3220,8 @@ function normalizeRemoteValue(key, value, filename, warnings) {
 }
 function readPkgDependencies(root) {
   try {
-    const pkgPath = path3.join(root, "package.json");
-    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path4.join(root, "package.json");
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
     return {
       ...pkg.dependencies ?? {},
       ...pkg.optionalDependencies ?? {},
@@ -1553,9 +3234,9 @@ function readPkgDependencies(root) {
 }
 function readInstalledVersion(root, specifier) {
   try {
-    const req = createRequire2(path3.join(root, "package.json"));
+    const req = createRequire3(path4.join(root, "package.json"));
     const pkgJsonPath = req.resolve(`${specifier}/package.json`, { paths: [root] });
-    const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf8"));
+    const pkg = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -1885,7 +3566,7 @@ function normalizeOptions(options, root, command) {
     shared,
     shareScope: shareScopeDefault,
     manifest: options.manifest === void 0 ? true : !!options.manifest,
-    runtimePlugins: (options.runtimePlugins ?? []).map((id) => id.startsWith(".") ? path3.resolve(root, id) : id),
+    runtimePlugins: (options.runtimePlugins ?? []).map((id) => id.startsWith(".") ? path4.resolve(root, id) : id),
     dts: options.dts === void 0 ? true : options.dts,
     root,
     pluginVersion: RUNTIME_VERSION,
@@ -1925,6 +3606,34 @@ var init_options = __esm({
   }
 });
 
+// src/dts-diagnostics.ts
+import path5 from "node:path";
+function formatDeclarationDiagnostics(stdout, stderr, fallback, root, closure) {
+  const groups = [];
+  let current;
+  const clean = (text) => text.replace(/\u001b\[[0-9;]*m/g, "");
+  for (const line of clean(`${stdout}
+${stderr}`).split(/\r?\n/)) {
+    const file = line.match(/^(.+)\(\d+,\d+\): error TS\d+:/);
+    const global = /^(?:error )?TS\d+:/.test(line);
+    if (file || global) {
+      current = global || file && closure.has(path5.resolve(root, file[1].trim())) ? [line] : void 0;
+      if (current) groups.push(current);
+    } else if (current && line.trim()) {
+      current.push(line);
+    }
+  }
+  if (!groups.length) return clean(stderr || stdout || fallback).split(/\r?\n/).slice(0, 40).join("\n");
+  const shown = groups.slice(0, 5).flatMap((group) => group.slice(0, 8));
+  if (groups.length > 5) shown.push(`\u53E6\u6709 ${groups.length - 5} \u9879\u516C\u5F00\u58F0\u660E\u8BCA\u65AD\uFF0C\u8BF7\u8FD0\u884C\u63D0\u4F9B\u65B9\u7C7B\u578B\u68C0\u67E5\u67E5\u770B\u3002`);
+  return shown.join("\n");
+}
+var init_dts_diagnostics = __esm({
+  "src/dts-diagnostics.ts"() {
+    "use strict";
+  }
+});
+
 // src/dts-shared.ts
 function isSafeBundlePath(v) {
   if (typeof v !== "string" || v.length === 0) return false;
@@ -2016,13 +3725,13 @@ var init_dts_shared = __esm({
 });
 
 // src/dts-generate.ts
-import fs5 from "node:fs";
-import path4 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import crypto from "node:crypto";
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 import { execFile } from "node:child_process";
 function resolveFromRoot(root, pkg) {
-  const req = createRequire3(path4.join(root, "package.json"));
+  const req = createRequire4(path6.join(root, "package.json"));
   let resolved = null;
   for (const spec of [`${pkg}/package.json`, pkg]) {
     try {
@@ -2032,18 +3741,18 @@ function resolveFromRoot(root, pkg) {
     }
   }
   if (!resolved) return null;
-  let dir = path4.dirname(resolved);
-  for (let i = 0; i < 5 && !fs5.existsSync(path4.join(dir, "package.json")); i++) {
-    const parent = path4.dirname(dir);
+  let dir = path6.dirname(resolved);
+  for (let i = 0; i < 5 && !fs6.existsSync(path6.join(dir, "package.json")); i++) {
+    const parent = path6.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
-  return fs5.existsSync(path4.join(dir, "package.json")) ? dir : null;
+  return fs6.existsSync(path6.join(dir, "package.json")) ? dir : null;
 }
 function installHint(root, pkg) {
   const pkgManager = (() => {
-    if (fs5.existsSync(path4.join(root, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs5.existsSync(path4.join(root, "yarn.lock"))) return "yarn";
+    if (fs6.existsSync(path6.join(root, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs6.existsSync(path6.join(root, "yarn.lock"))) return "yarn";
     return "npm";
   })();
   const devFlag = pkgManager === "pnpm" ? "-D" : "--save-dev";
@@ -2068,12 +3777,12 @@ function computeStaticClosure(ts, entryFiles, resolver, root) {
     closure.add(file);
     let text;
     try {
-      text = fs5.readFileSync(file, "utf8");
+      text = fs6.readFileSync(file, "utf8");
     } catch {
       continue;
     }
     if (file.endsWith(".vue")) {
-      const req = createRequire3(path4.join(root, "package.json"));
+      const req = createRequire4(path6.join(root, "package.json"));
       const { parse: parse2 } = req("vue/compiler-sfc");
       const { descriptor } = parse2(text);
       text = [descriptor.script?.content, descriptor.scriptSetup?.content].filter(Boolean).join("\n");
@@ -2095,16 +3804,16 @@ import ${JSON.stringify(descriptor.script.src)}`;
       const r = resolver(spec, file);
       let resolved = r && !r.fromNodeModules ? r.resolved : null;
       if (!resolved) {
-        const base = path4.resolve(path4.dirname(file), spec);
-        for (const c of [base, `${base}.vue`, `${base}.ts`, `${base}.tsx`, path4.join(base, "index.ts")]) {
-          if (fs5.existsSync(c)) {
+        const base = path6.resolve(path6.dirname(file), spec);
+        for (const c of [base, `${base}.vue`, `${base}.ts`, `${base}.tsx`, path6.join(base, "index.ts")]) {
+          if (fs6.existsSync(c)) {
             resolved = c;
             break;
           }
         }
       }
-      if (resolved && !resolved.includes(`${path4.sep}node_modules${path4.sep}`)) {
-        queue.push(path4.resolve(resolved));
+      if (resolved && !resolved.includes(`${path6.sep}node_modules${path6.sep}`)) {
+        queue.push(path6.resolve(resolved));
       }
     }
   }
@@ -2115,7 +3824,7 @@ function parseErrorFiles(stdout, root) {
   const out = /* @__PURE__ */ new Set();
   for (const line of stdout.split("\n")) {
     const m = line.match(/^([^)(]+)\((\d+),(\d+)\): error TS/);
-    if (m) out.add(path4.resolve(root, m[1].trim()));
+    if (m) out.add(path6.resolve(root, m[1].trim()));
   }
   return out;
 }
@@ -2124,17 +3833,17 @@ function resolveTypesEntries(root, baseCo, diagnostics) {
   if (raw === void 0) return [];
   baseCo.types = [];
   if (!Array.isArray(raw)) return [];
-  const req = createRequire3(path4.join(root, "package.json"));
+  const req = createRequire4(path6.join(root, "package.json"));
   const out = [];
   for (const entry of raw) {
     if (typeof entry !== "string" || entry.length === 0) continue;
-    const direct = [path4.resolve(root, `${entry}.d.ts`), path4.resolve(root, entry, "index.d.ts"), path4.resolve(root, "node_modules", `${entry}.d.ts`), path4.resolve(root, "node_modules", entry, "index.d.ts"), path4.resolve(root, "node_modules/@types", entry, "index.d.ts")];
-    let hit = direct.find((c) => fs5.existsSync(c));
-    if (!hit && !entry.startsWith(".") && !path4.isAbsolute(entry)) {
+    const direct = [path6.resolve(root, `${entry}.d.ts`), path6.resolve(root, entry, "index.d.ts"), path6.resolve(root, "node_modules", `${entry}.d.ts`), path6.resolve(root, "node_modules", entry, "index.d.ts"), path6.resolve(root, "node_modules/@types", entry, "index.d.ts")];
+    let hit = direct.find((c) => fs6.existsSync(c));
+    if (!hit && !entry.startsWith(".") && !path6.isAbsolute(entry)) {
       try {
         const r = req.resolve(entry);
         for (const c of [r.replace(/\.js$/, ".d.ts"), `${r}.d.ts`, r]) {
-          if (c.endsWith(".d.ts") && fs5.existsSync(c)) {
+          if (c.endsWith(".d.ts") && fs6.existsSync(c)) {
             hit = c;
             break;
           }
@@ -2152,33 +3861,33 @@ function hasVueFilesUnderSources(root) {
     if (budget.left <= 0) return false;
     let entries;
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const e of entries) {
       if (e.name === "node_modules" || e.name === ".git" || e.name === "dist") continue;
-      const p = path4.join(dir, e.name);
+      const p = path6.join(dir, e.name);
       budget.left -= 1;
       if (e.isFile() && e.name.endsWith(".vue")) return true;
       if (e.isDirectory() && scan(p, budget)) return true;
     }
     return false;
   };
-  const srcDir = path4.join(root, "src");
-  return scan(fs5.existsSync(srcDir) ? srcDir : root, { left: 2e3 });
+  const srcDir = path6.join(root, "src");
+  return scan(fs6.existsSync(srcDir) ? srcDir : root, { left: 2e3 });
 }
 function commonDirOf(files) {
   if (files.length === 0) return "";
-  let dir = path4.dirname(files[0]);
+  let dir = path6.dirname(files[0]);
   for (const f of files) {
-    const rel = path4.relative(dir, f);
+    const rel = path6.relative(dir, f);
     if (rel.startsWith("..")) {
-      const parts = path4.dirname(f).split(path4.sep);
-      const cur = dir.split(path4.sep);
+      const parts = path6.dirname(f).split(path6.sep);
+      const cur = dir.split(path6.sep);
       let i = 0;
       while (i < parts.length && i < cur.length && parts[i] === cur[i]) i++;
-      dir = parts.slice(0, i).join(path4.sep) || path4.sep;
+      dir = parts.slice(0, i).join(path6.sep) || path6.sep;
     }
   }
   return dir;
@@ -2219,10 +3928,10 @@ function loadTsContext(root, ts, diagnostics) {
     diagnostics.push(`tsconfig \u89E3\u6790\u5931\u8D25\uFF08${tsconfigFile}\uFF09\uFF1A${ts.flattenDiagnosticMessageText(raw.error.messageText, " ")}`);
     return null;
   }
-  const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, path4.dirname(tsconfigFile));
+  const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, path6.dirname(tsconfigFile));
   const co = { ...parsed.options };
-  if (typeof co.baseUrl === "string" && !path4.isAbsolute(co.baseUrl)) {
-    co.baseUrl = path4.resolve(path4.dirname(tsconfigFile), co.baseUrl);
+  if (typeof co.baseUrl === "string" && !path6.isAbsolute(co.baseUrl)) {
+    co.baseUrl = path6.resolve(path6.dirname(tsconfigFile), co.baseUrl);
   }
   if (parsed.errors.length > 0) {
     const fatal = parsed.errors.filter((e) => e.category === ts.DiagnosticCategory.Error);
@@ -2238,7 +3947,7 @@ function loadTsContext(root, ts, diagnostics) {
     compilerOptions: co,
     rawOptions: raw.config.compilerOptions ?? {},
     projectFiles: parsed.fileNames.filter((f) => !f.endsWith(".d.ts")),
-    ambientInputs: parsed.fileNames.filter((f) => f.endsWith(".d.ts") && !f.includes(`${path4.sep}node_modules${path4.sep}`)),
+    ambientInputs: parsed.fileNames.filter((f) => f.endsWith(".d.ts") && !f.includes(`${path6.sep}node_modules${path6.sep}`)),
     tsconfigFile
   };
 }
@@ -2249,7 +3958,7 @@ function makeResolver(ts, co) {
     let resolved = r.resolvedModule?.resolvedFileName;
     if (resolved?.endsWith(".vue.ts") && ts.sys.fileExists(resolved.slice(0, -3))) resolved = resolved.slice(0, -3);
     if (!resolved) return null;
-    return { resolved, fromNodeModules: resolved.includes(`${path4.sep}node_modules${path4.sep}`) };
+    return { resolved, fromNodeModules: resolved.includes(`${path6.sep}node_modules${path6.sep}`) };
   };
 }
 async function generateTypesBundle(input) {
@@ -2262,7 +3971,7 @@ async function generateTypesBundle(input) {
   if (!tsPkgDir) {
     return { ok: false, diagnostics: [`\u63D0\u4F9B\u65B9\u5DE5\u7A0B\u672A\u5B89\u88C5 typescript\uFF08\u58F0\u660E\u751F\u6210\u5FC5\u9700\uFF09\u3002${installHint(root, "typescript")}`] };
   }
-  const tsReq = createRequire3(path4.join(tsPkgDir, "package.json"));
+  const tsReq = createRequire4(path6.join(tsPkgDir, "package.json"));
   const ts = tsReq("typescript");
   const ctx = loadTsContext(root, ts, diagnostics);
   if (!ctx) return { ok: false, diagnostics };
@@ -2270,15 +3979,15 @@ async function generateTypesBundle(input) {
   const entryMap = /* @__PURE__ */ new Map();
   for (const expose of exposes) {
     const raw = expose.import.replace(/^\.?\//, "");
-    let abs = path4.resolve(root, raw);
-    if (!fs5.existsSync(abs)) {
-      const viaResolver = resolver(expose.import, path4.join(root, "package.json"));
+    let abs = path6.resolve(root, raw);
+    if (!fs6.existsSync(abs)) {
+      const viaResolver = resolver(expose.import, path6.join(root, "package.json"));
       if (viaResolver && !viaResolver.fromNodeModules) abs = viaResolver.resolved;
     }
     abs = abs.replace(/\.js$/, ".ts");
-    if (!fs5.existsSync(abs) && fs5.existsSync(`${abs}.ts`)) abs = `${abs}.ts`;
-    if (!fs5.existsSync(abs) && fs5.existsSync(`${abs}.tsx`)) abs = `${abs}.tsx`;
-    if (!fs5.existsSync(abs)) {
+    if (!fs6.existsSync(abs) && fs6.existsSync(`${abs}.ts`)) abs = `${abs}.ts`;
+    if (!fs6.existsSync(abs) && fs6.existsSync(`${abs}.tsx`)) abs = `${abs}.tsx`;
+    if (!fs6.existsSync(abs)) {
       diagnostics.push(`\u66B4\u9732\u5165\u53E3 ${expose.name} \u7684\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728\uFF08${expose.import}\uFF09\u3002\u8BF7\u6838\u5BF9 exposes \u914D\u7F6E\u3002`);
       continue;
     }
@@ -2304,14 +4013,14 @@ async function generateTypesBundle(input) {
       };
     }
     tool = "vue-tsc";
-    const vueTscPkg = JSON.parse(fs5.readFileSync(path4.join(vueTscDir, "package.json"), "utf8"));
+    const vueTscPkg = JSON.parse(fs6.readFileSync(path6.join(vueTscDir, "package.json"), "utf8"));
     const binRel = vueTscPkg.bin?.["vue-tsc"] ?? vueTscPkg.bin?.["vue-tsc.js"] ?? "bin/vue-tsc.js";
-    const binPath = path4.resolve(vueTscDir, binRel);
-    if (!fs5.existsSync(binPath)) {
+    const binPath = path6.resolve(vueTscDir, binRel);
+    if (!fs6.existsSync(binPath)) {
       return { ok: false, diagnostics: [`vue-tsc \u5165\u53E3\u4E0D\u5B58\u5728\uFF08${binPath}\uFF09\u3002\u8BF7\u91CD\u65B0\u5B89\u88C5 vue-tsc\u3002`] };
     }
-    const tmpCfg = path4.join(root, `.fulgurjs-types-tsconfig-${process.pid}-${crypto.randomUUID()}.json`);
-    const outDir = fs5.mkdtempSync(path4.join(root, "node_modules", ".fulgurjs-types-emit-"));
+    const tmpCfg = path6.join(root, `.fulgurjs-types-tsconfig-${process.pid}-${crypto.randomUUID()}.json`);
+    const outDir = fs6.mkdtempSync(path6.join(root, "node_modules", ".fulgurjs-types-emit-"));
     const baseCo = { ...rawOptionsWithInherited(ctx) };
     delete baseCo.noEmit;
     delete baseCo.incremental;
@@ -2321,7 +4030,7 @@ async function generateTypesBundle(input) {
     delete baseCo.declarationDir;
     delete baseCo.extends;
     const resolvedTypeFiles = resolveTypesEntries(root, baseCo, diagnostics);
-    fs5.writeFileSync(tmpCfg, JSON.stringify({
+    fs6.writeFileSync(tmpCfg, JSON.stringify({
       compilerOptions: {
         ...baseCo,
         noEmit: false,
@@ -2336,17 +4045,17 @@ async function generateTypesBundle(input) {
         rootDir
       },
       include: [
-        ...entryFiles.map((f) => path4.relative(root, f)),
-        ...ctx.ambientInputs.map((f) => path4.relative(root, f)),
-        ...resolvedTypeFiles.map((f) => path4.relative(root, f))
+        ...entryFiles.map((f) => path6.relative(root, f)),
+        ...ctx.ambientInputs.map((f) => path6.relative(root, f)),
+        ...resolvedTypeFiles.map((f) => path6.relative(root, f))
       ]
     }));
-    if (process.env.FG_DUMP_TSCFG) fs5.writeFileSync(process.env.FG_DUMP_TSCFG, fs5.readFileSync(tmpCfg, "utf8"));
+    if (process.env.FG_DUMP_TSCFG) fs6.writeFileSync(process.env.FG_DUMP_TSCFG, fs6.readFileSync(tmpCfg, "utf8"));
     try {
       await new Promise((resolve2, reject) => {
         const child = execFile(
           process.execPath,
-          [binPath, "-p", tmpCfg, "--noErrorTruncation"],
+          [binPath, "-p", tmpCfg, "--noErrorTruncation", "--pretty", "false"],
           { cwd: root, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, timeout: 10 * 60 * 1e3 },
           (err, stdout, stderr) => {
             if (err) {
@@ -2359,12 +4068,7 @@ async function generateTypesBundle(input) {
               const closureErrs = new Set([...errFiles].filter((f) => closure.has(f)));
               const globalError = /(?:^|\n)(?:error )?TS\d+:/.test(String(stdout ?? "") + "\n" + String(stderr ?? ""));
               if (closureErrs.size > 0 || globalError || errFiles.size === 0) {
-                const tail = `${String(stdout ?? "")}
-${String(stderr ?? "")}
-${err.message}`.split("\n").filter((line) => {
-                  const m = line.match(/^([^)(]+)\(\d+,\d+\): error TS/);
-                  return !m || closureErrs.has(path4.resolve(root, m[1].trim()));
-                }).slice(-40).join("\n");
+                const tail = formatDeclarationDiagnostics(String(stdout ?? ""), String(stderr ?? ""), err.message, root, closure);
                 diagnostics.push(`vue-tsc \u58F0\u660E\u751F\u6210\u5931\u8D25\uFF08\u66B4\u9732\u95ED\u5305\u5185\u5B58\u5728\u7F16\u8BD1\u9519\u8BEF\uFF09\u2014\u2014\u7C7B\u578B\u8D44\u6E90\u672A\u4EA7\u51FA\uFF1A
 ${tail}`);
                 reject(err);
@@ -2379,16 +4083,16 @@ ${tail}`);
         signal?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
       });
     } catch {
-      fs5.rmSync(outDir, { recursive: true, force: true });
-      fs5.rmSync(tmpCfg, { force: true });
+      fs6.rmSync(outDir, { recursive: true, force: true });
+      fs6.rmSync(tmpCfg, { force: true });
       return { ok: false, diagnostics };
     } finally {
-      fs5.rmSync(tmpCfg, { force: true });
+      fs6.rmSync(tmpCfg, { force: true });
     }
     collectEmitted(ts, outDir, rootDir, emitted, closure);
-    fs5.rmSync(outDir, { recursive: true, force: true });
+    fs6.rmSync(outDir, { recursive: true, force: true });
   } else {
-    const outDir = fs5.mkdtempSync(path4.join(root, "node_modules", ".fulgurjs-types-emit-"));
+    const outDir = fs6.mkdtempSync(path6.join(root, "node_modules", ".fulgurjs-types-emit-"));
     const program = ts.createProgram([...entryFiles, ...ctx.ambientInputs, ...resolveTypesEntries(root, ctx.rawOptions, [])], {
       ...ctx.compilerOptions,
       noEmit: false,
@@ -2406,13 +4110,13 @@ ${tail}`);
       ...program.getOptionsDiagnostics(),
       ...program.getSemanticDiagnostics(),
       ...program.getDeclarationDiagnostics()
-    ].filter((d) => d.category === ts.DiagnosticCategory.Error).filter((d) => !d.file || closure.has(path4.resolve(d.file.fileName)));
+    ].filter((d) => d.category === ts.DiagnosticCategory.Error).filter((d) => !d.file || closure.has(path6.resolve(d.file.fileName)));
     if (errs.length > 0) {
-      fs5.rmSync(outDir, { recursive: true, force: true });
+      fs6.rmSync(outDir, { recursive: true, force: true });
       diagnostics.push(
         `\u58F0\u660E\u751F\u6210\u5931\u8D25\uFF1A\u66B4\u9732\u95ED\u5305\u5185\u5B58\u5728 ${errs.length} \u4E2A\u7F16\u8BD1\u9519\u8BEF\u2014\u2014\u7C7B\u578B\u8D44\u6E90\u672A\u4EA7\u51FA\uFF08\u4FEE\u590D\u540E\u91CD\u65B0\u6784\u5EFA/\u91CD\u542F dev\uFF09\u3002\u524D\u82E5\u5E72\u6761\uFF1A`,
         ...errs.slice(0, 20).map((d) => {
-          const f = d.file ? path4.relative(root, d.file.fileName) : "?";
+          const f = d.file ? path6.relative(root, d.file.fileName) : "?";
           const pos = d.file ? d.file.getLineAndCharacterOfPosition(d.start ?? 0) : { line: 0 };
           return `  ${f}:${pos.line + 1} TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, " ")}`;
         })
@@ -2421,14 +4125,14 @@ ${tail}`);
     }
     const emitResult = program.emit();
     if (emitResult.emitSkipped) {
-      fs5.rmSync(outDir, { recursive: true, force: true });
+      fs6.rmSync(outDir, { recursive: true, force: true });
       return { ok: false, diagnostics: ["TypeScript \u58F0\u660E emit \u5931\u8D25\uFF08emitSkipped\uFF09\u3002\u8BF7\u68C0\u67E5 tsconfig \u7F16\u8BD1\u9009\u9879\u3002"] };
     }
     collectEmitted(ts, outDir, rootDir, emitted, closure);
-    fs5.rmSync(outDir, { recursive: true, force: true });
+    fs6.rmSync(outDir, { recursive: true, force: true });
   }
   for (const file of closure) {
-    if (file.endsWith(".d.ts")) emitted.set(file, fs5.readFileSync(file, "utf8"));
+    if (file.endsWith(".d.ts")) emitted.set(file, fs6.readFileSync(file, "utf8"));
   }
   if (signal?.aborted) return { ok: false, diagnostics: ["\u58F0\u660E\u751F\u6210\u88AB\u4E2D\u6B62\u3002"] };
   if (emitted.size === 0) {
@@ -2437,7 +4141,7 @@ ${tail}`);
   const externals = /* @__PURE__ */ new Set();
   const srcToRel = /* @__PURE__ */ new Map();
   for (const srcAbs of emitted.keys()) {
-    const rel = path4.relative(rootDir, srcAbs).split(path4.sep).join("/");
+    const rel = path6.relative(rootDir, srcAbs).split(path6.sep).join("/");
     const declRel = rel.endsWith(".d.ts") ? `files/${rel}` : rel.endsWith(".vue") ? `files/${rel}.d.ts` : `files/${rel.replace(/\.(mts|cts|ts|tsx|jsx|js)$/, "")}.d.ts`;
     srcToRel.set(srcAbs, declRel);
   }
@@ -2452,7 +4156,7 @@ ${tail}`);
   for (const [srcAbs, text] of emitted) {
     const rel = srcToRel.get(srcAbs);
     if (text.includes(root)) {
-      diagnostics.push(`\u58F0\u660E\u6587\u4EF6\u5305\u542B\u672C\u673A\u7EDD\u5BF9\u8DEF\u5F84\uFF08${path4.relative(root, srcAbs)}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u4EA7\u51FA\u3002\u8BF7\u68C0\u67E5\u8BE5\u6587\u4EF6\u7684\u7C7B\u578B\u662F\u5426\u5F15\u7528\u4E86\u5B57\u9762\u8DEF\u5F84\u3002`);
+      diagnostics.push(`\u58F0\u660E\u6587\u4EF6\u5305\u542B\u672C\u673A\u7EDD\u5BF9\u8DEF\u5F84\uFF08${path6.relative(root, srcAbs)}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u4EA7\u51FA\u3002\u8BF7\u68C0\u67E5\u8BE5\u6587\u4EF6\u7684\u7C7B\u578B\u662F\u5426\u5F15\u7528\u4E86\u5B57\u9762\u8DEF\u5F84\u3002`);
       leaked = true;
     }
     files.set(rel, text);
@@ -2483,27 +4187,27 @@ ${tail}`);
   return { ok: true, files, index: fullIndex, tool, fileCount: filesDigest ? Object.keys(filesDigest).length : 0 };
 }
 function collectEmitted(ts, outDir, rootDir, out, closure) {
-  const walk = (dir) => fs5.readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
-    const p = path4.join(dir, d.name);
+  const walk = (dir) => fs6.readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
+    const p = path6.join(dir, d.name);
     return d.isDirectory() ? walk(p) : [p];
   });
-  if (!fs5.existsSync(outDir)) return;
+  if (!fs6.existsSync(outDir)) return;
   for (const file of walk(outDir)) {
     if (!file.endsWith(".d.ts")) continue;
-    const rel = path4.relative(outDir, file);
+    const rel = path6.relative(outDir, file);
     const srcRel = rel.endsWith(".vue.d.ts") ? rel.replace(/\.d\.ts$/, "") : rel.replace(/\.d\.ts$/, ".ts");
-    let srcAbs = path4.join(rootDir, srcRel);
-    if (!out.has(srcAbs) && !fs5.existsSync(srcAbs)) {
+    let srcAbs = path6.join(rootDir, srcRel);
+    if (!out.has(srcAbs) && !fs6.existsSync(srcAbs)) {
       for (const ext of [".tsx", ".jsx", ".mts", ".cts", ".js"]) {
-        const candidate = path4.join(rootDir, rel.replace(/\.d\.ts$/, ext));
-        if (fs5.existsSync(candidate)) {
+        const candidate = path6.join(rootDir, rel.replace(/\.d\.ts$/, ext));
+        if (fs6.existsSync(candidate)) {
           srcAbs = candidate;
           break;
         }
       }
     }
     if (!closure.has(srcAbs)) continue;
-    out.set(srcAbs, fs5.readFileSync(file, "utf8"));
+    out.set(srcAbs, fs6.readFileSync(file, "utf8"));
   }
   void ts;
 }
@@ -2511,7 +4215,7 @@ function rewriteSpecifiers(ts, text, srcAbs, srcToRel, resolver, externals, root
   const declRel = srcToRel.get(srcAbs);
   const fail = (spec) => {
     diagnostics.push(
-      `\u58F0\u660E\u4F9D\u8D56\u4E0D\u5B8C\u6574\uFF1A${path4.relative(root, srcAbs)} \u7684\u5BFC\u5165 "${spec}" \u65E0\u6CD5\u89E3\u6790\u5230\u5DE5\u7A0B\u5185\u6587\u4EF6\u3002\u8BF7\u68C0\u67E5 tsconfig paths/include \u662F\u5426\u8986\u76D6\u8BE5\u4F9D\u8D56\u3002`
+      `\u58F0\u660E\u4F9D\u8D56\u4E0D\u5B8C\u6574\uFF1A${path6.relative(root, srcAbs)} \u7684\u5BFC\u5165 "${spec}" \u65E0\u6CD5\u89E3\u6790\u5230\u5DE5\u7A0B\u5185\u6587\u4EF6\u3002\u8BF7\u68C0\u67E5 tsconfig paths/include \u662F\u5426\u8986\u76D6\u8BE5\u4F9D\u8D56\u3002`
     );
     return null;
   };
@@ -2536,9 +4240,9 @@ function rewriteSpecifiers(ts, text, srcAbs, srcToRel, resolver, externals, root
     return srcToRel.get(resolved) ?? fail(spec);
   };
   const rewriteTo = (targetRel) => {
-    const fromDir = path4.posix.dirname(declRel);
+    const fromDir = path6.posix.dirname(declRel);
     const toNoExt = targetRel.replace(/\.d\.ts$/, "");
-    let rel = path4.posix.relative(fromDir, toNoExt);
+    let rel = path6.posix.relative(fromDir, toNoExt);
     if (!rel.startsWith(".")) rel = `./${rel}`;
     return rel;
   };
@@ -2610,6 +4314,7 @@ var INHERITABLE_KEYS;
 var init_dts_generate = __esm({
   "src/dts-generate.ts"() {
     "use strict";
+    init_dts_diagnostics();
     init_dts_shared();
     INHERITABLE_KEYS = [
       "paths",
@@ -2648,8 +4353,8 @@ function buildAmbientDeclarations(input) {
     if (!isSafeBundlePath(meta.declaration)) continue;
     const exposeName = expose.replace(/^\.\//, "");
     let name = `${alias}/${exposeName}`;
-    let n = 2;
-    while (used.has(name)) name = `${alias}/${exposeName}$${n++}`;
+    let n2 = 2;
+    while (used.has(name)) name = `${alias}/${exposeName}$${n2++}`;
     used.add(name);
     ambientOf.set(meta.declaration, name);
   }
@@ -2657,8 +4362,8 @@ function buildAmbientDeclarations(input) {
     if (ambientOf.has(rel)) continue;
     const internal = rel.replace(/^files\//, "").replace(/(\.vue)?\.d\.ts$/, "");
     let name = `${alias}/__internal/${internal}`;
-    let n = 2;
-    while (used.has(name)) name = `${alias}/__internal/${internal}$${n++}`;
+    let n2 = 2;
+    while (used.has(name)) name = `${alias}/__internal/${internal}$${n2++}`;
     used.add(name);
     ambientOf.set(rel, name);
   }
@@ -2708,11 +4413,11 @@ ${indented.trimEnd()}
       ``
     ].join("\n")
   );
-  return { files, publicModules: [...ambientOf.values()].filter((n) => !n.includes("/__internal/")), warnings };
+  return { files, publicModules: [...ambientOf.values()].filter((n2) => !n2.includes("/__internal/")), warnings };
 }
 function rewriteRelativeSpecifiers(text, bundleRel, resolve2, warnings) {
   const dir = bundleRel.includes("/") ? bundleRel.slice(0, bundleRel.lastIndexOf("/")) : "";
-  const targetOf = (spec) => {
+  const targetOf2 = (spec) => {
     const joined = dir ? `${dir}/${spec}` : spec;
     const norm = pathNormalize(joined);
     const candidates = [norm, `${norm}.d.ts`, norm.endsWith(".vue") ? `${norm}.d.ts` : `${norm}.vue.d.ts`];
@@ -2723,19 +4428,19 @@ function rewriteRelativeSpecifiers(text, bundleRel, resolve2, warnings) {
     return null;
   };
   let out = text.replace(/(\bfrom\s*)(['"])(\.\.?\/[^'"]+)\2/g, (full, pre, q, spec) => {
-    const name = targetOf(spec);
+    const name = targetOf2(spec);
     return name ? `${pre}${q}${name}${q}` : full;
   });
   out = out.replace(/(\bimport\s*)(['"])(\.\.?\/[^'"]+)\2/g, (full, pre, q, spec) => {
-    const name = targetOf(spec);
+    const name = targetOf2(spec);
     return name ? `${pre}${q}${name}${q}` : full;
   });
   out = out.replace(/(\bexport\s*\*\s*from\s*)(['"])(\.\.?\/[^'"]+)\2/g, (full, pre, q, spec) => {
-    const name = targetOf(spec);
+    const name = targetOf2(spec);
     return name ? `${pre}${q}${name}${q}` : full;
   });
   out = out.replace(/import\((['"])(\.\.?\/[^'"]+)\1\)/g, (full, q, spec) => {
-    const name = targetOf(spec);
+    const name = targetOf2(spec);
     return name ? `import(${q}${name}${q})` : full;
   });
   if (/(?:\bfrom\s*|\bimport\s*|import\()['"]\.\.?\/[^'"]+['"]/.test(out)) {
@@ -2770,15 +4475,15 @@ var init_dts_ambient = __esm({
 });
 
 // src/dts-discovery.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 function stripJsoncForConfig(text) {
   let out = "";
   let i = 0;
-  const n = text.length;
+  const n2 = text.length;
   let inStr = false;
   let esc = false;
-  while (i < n) {
+  while (i < n2) {
     const c = text[i];
     if (inStr) {
       out += c;
@@ -2795,12 +4500,12 @@ function stripJsoncForConfig(text) {
       continue;
     }
     if (c === "/" && text[i + 1] === "/") {
-      while (i < n && text[i] !== "\n") i++;
+      while (i < n2 && text[i] !== "\n") i++;
       continue;
     }
     if (c === "/" && text[i + 1] === "*") {
       i += 2;
-      while (i < n && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      while (i < n2 && !(text[i] === "*" && text[i + 1] === "/")) i++;
       i += 2;
       continue;
     }
@@ -2811,7 +4516,7 @@ function stripJsoncForConfig(text) {
 }
 function readCfg(file) {
   try {
-    const raw = JSON.parse(stripJsoncForConfig(fs6.readFileSync(file, "utf8")));
+    const raw = JSON.parse(stripJsoncForConfig(fs7.readFileSync(file, "utf8")));
     const cfg = { file };
     for (const key of ["include", "files", "exclude"]) {
       const v = raw[key];
@@ -2835,25 +4540,25 @@ function effectiveCfg(cfg, depth = 0) {
     const parentFile = resolveConfigFile(parent, cfg.file);
     if (!parentFile) continue;
     const parentCfg = effectiveCfg(readCfg(parentFile) ?? { file: parentFile }, depth + 1);
-    const dirOf = (f, base) => path5.resolve(path5.dirname(base), f);
+    const dirOf = (f, base) => path7.resolve(path7.dirname(base), f);
     if (parentCfg.include && !cfg.include) {
-      merged.include = parentCfg.include.map((p) => path5.relative(path5.dirname(cfg.file), dirOf(p, parentFile)) || ".");
+      merged.include = parentCfg.include.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)) || ".");
     }
     if (parentCfg.files && !cfg.files) {
-      merged.files = parentCfg.files.map((p) => path5.relative(path5.dirname(cfg.file), dirOf(p, parentFile)));
+      merged.files = parentCfg.files.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)));
     }
     if (parentCfg.exclude && !cfg.exclude) {
-      merged.exclude = parentCfg.exclude.map((p) => path5.relative(path5.dirname(cfg.file), dirOf(p, parentFile)));
+      merged.exclude = parentCfg.exclude.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)));
     }
   }
   return merged;
 }
 function resolveConfigFile(value, declaringFile) {
-  let candidate = path5.resolve(path5.dirname(declaringFile), value);
+  let candidate = path7.resolve(path7.dirname(declaringFile), value);
   if (!candidate.endsWith(".json")) candidate += ".json";
-  if (fs6.existsSync(candidate)) return candidate;
-  const asDir = path5.join(candidate, "tsconfig.json");
-  return fs6.existsSync(asDir) ? asDir : null;
+  if (fs7.existsSync(candidate)) return candidate;
+  const asDir = path7.join(candidate, "tsconfig.json");
+  return fs7.existsSync(asDir) ? asDir : null;
 }
 function patternCoversDir(pattern, target, cfgDir) {
   const norm = pattern.replace(/^\.\//, "");
@@ -2863,15 +4568,15 @@ function patternCoversDir(pattern, target, cfgDir) {
   if (norm.includes("**")) base = norm.slice(0, norm.indexOf("**")).replace(/\/+$/, "");
   else if (norm.endsWith("/*")) base = norm.slice(0, -2);
   else base = norm.replace(/\/+$/, "");
-  const abs = base === "" || base === "." ? cfgDir : path5.resolve(cfgDir, base);
-  return target === abs || target.startsWith(abs + path5.sep);
+  const abs = base === "" || base === "." ? cfgDir : path7.resolve(cfgDir, base);
+  return target === abs || target.startsWith(abs + path7.sep);
 }
 function checkTypesDiscovery(root, typesRoot) {
-  const relTypes = path5.relative(root, typesRoot) || ".";
+  const relTypes = path7.relative(root, typesRoot) || ".";
   const configs = [];
-  let primary = path5.join(root, "tsconfig.json");
-  if (!fs6.existsSync(primary)) {
-    const candidates = fs6.existsSync(root) ? fs6.readdirSync(root).filter((f) => /^tsconfig[\w.-]*\.json$/i.test(f)).map((f) => path5.join(root, f)) : [];
+  let primary = path7.join(root, "tsconfig.json");
+  if (!fs7.existsSync(primary)) {
+    const candidates = fs7.existsSync(root) ? fs7.readdirSync(root).filter((f) => /^tsconfig[\w.-]*\.json$/i.test(f)).map((f) => path7.join(root, f)) : [];
     if (candidates.length === 0) {
       return {
         covered: false,
@@ -2883,7 +4588,7 @@ function checkTypesDiscovery(root, typesRoot) {
     if (candidates.length > 1) {
       let covered = false;
       for (const file of candidates) {
-        configs.push(path5.relative(root, file));
+        configs.push(path7.relative(root, file));
         if (configCovers(file, typesRoot)) covered = true;
       }
       if (covered) return { covered: true, configs, fixHint: null };
@@ -2894,34 +4599,34 @@ function checkTypesDiscovery(root, typesRoot) {
       };
     }
   }
-  configs.push(path5.relative(root, primary));
+  configs.push(path7.relative(root, primary));
   if (configCovers(primary, typesRoot)) return { covered: true, configs, fixHint: null };
   return {
     covered: false,
     configs,
-    fixHint: `TYP-006 \u7C7B\u578B\u76EE\u5F55 ${relTypes} \u672A\u88AB ${path5.relative(root, primary)} \u7684 include/files \u8986\u76D6\uFF08exclude \u6216\u4E25\u683C files \u767D\u540D\u5355\u90FD\u4F1A\u8BA9\u751F\u6210\u58F0\u660E\u5BF9 IDE/tsc \u4E0D\u53EF\u89C1\uFF09\u3002\u6700\u5C0F\u4FEE\u6CD5\uFF1Ainclude \u52A0\u5165 "${relTypes}/**/*.d.ts"\uFF0C\u6216\u79FB\u9664\u5BF9\u5B83\u7684 exclude/files \u9650\u5236\u3002`
+    fixHint: `TYP-006 \u7C7B\u578B\u76EE\u5F55 ${relTypes} \u672A\u88AB ${path7.relative(root, primary)} \u7684 include/files \u8986\u76D6\uFF08exclude \u6216\u4E25\u683C files \u767D\u540D\u5355\u90FD\u4F1A\u8BA9\u751F\u6210\u58F0\u660E\u5BF9 IDE/tsc \u4E0D\u53EF\u89C1\uFF09\u3002\u6700\u5C0F\u4FEE\u6CD5\uFF1Ainclude \u52A0\u5165 "${relTypes}/**/*.d.ts"\uFF0C\u6216\u79FB\u9664\u5BF9\u5B83\u7684 exclude/files \u9650\u5236\u3002`
   };
 }
 function configCovers(cfgFile, typesRoot) {
   const raw = readCfg(cfgFile);
   if (!raw) return false;
   const cfg = effectiveCfg(raw);
-  const cfgDir = path5.dirname(cfgFile);
+  const cfgDir = path7.dirname(cfgFile);
   const isSolution = Array.isArray(cfg.files) && cfg.files.length === 0 && !cfg.include;
   if (isSolution && cfg.references && cfg.references.length > 0) {
     return cfg.references.some((ref) => {
-      const refFile = resolveConfigFile(ref.startsWith(".") || path5.isAbsolute(ref) ? ref : `./${ref}`, cfgFile);
+      const refFile = resolveConfigFile(ref.startsWith(".") || path7.isAbsolute(ref) ? ref : `./${ref}`, cfgFile);
       return refFile !== null && configCovers(refFile, typesRoot);
     });
   }
   if (Array.isArray(cfg.files) && cfg.files.length > 0) {
     return cfg.files.some((f) => {
-      const abs = path5.resolve(cfgDir, f);
-      return abs === typesRoot || abs.startsWith(typesRoot + path5.sep);
+      const abs = path7.resolve(cfgDir, f);
+      return abs === typesRoot || abs.startsWith(typesRoot + path7.sep);
     });
   }
   const includes = cfg.include;
-  if (!includes) return typesRoot === cfgDir || typesRoot.startsWith(cfgDir + path5.sep);
+  if (!includes) return typesRoot === cfgDir || typesRoot.startsWith(cfgDir + path7.sep);
   const included = includes.some((p) => patternCoversDir(p, typesRoot, cfgDir));
   if (!included) return false;
   if (cfg.exclude && cfg.exclude.some((p) => patternCoversDir(p, typesRoot, cfgDir))) return false;
@@ -2934,8 +4639,8 @@ var init_dts_discovery = __esm({
 });
 
 // src/dts-sync.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 import crypto2 from "node:crypto";
 function readManifestTypes(m) {
   const t = m.types;
@@ -2971,7 +4676,7 @@ async function fetchText(url, timeoutMs) {
 }
 function readMetadata(dir) {
   try {
-    const raw = JSON.parse(fs7.readFileSync(path6.join(dir, METADATA_FILE), "utf8"));
+    const raw = JSON.parse(fs8.readFileSync(path8.join(dir, METADATA_FILE), "utf8"));
     if (raw.generator !== "@fulgurjs/federation" || typeof raw.revision !== "string" || !Array.isArray(raw.files)) return null;
     return raw;
   } catch {
@@ -2981,19 +4686,19 @@ function readMetadata(dir) {
 function cleanupOwnFiles(dir, meta) {
   for (const f of meta.files) {
     if (!isSafeBundlePath(f)) continue;
-    fs7.rmSync(path6.join(dir, f), { force: true });
+    fs8.rmSync(path8.join(dir, f), { force: true });
   }
-  fs7.rmSync(path6.join(dir, METADATA_FILE), { force: true });
+  fs8.rmSync(path8.join(dir, METADATA_FILE), { force: true });
   try {
-    if (fs7.readdirSync(dir).length === 0) fs7.rmdirSync(dir);
+    if (fs8.readdirSync(dir).length === 0) fs8.rmdirSync(dir);
   } catch {
   }
 }
 function sweepStaleStaging(typesRoot, alias) {
-  if (!fs7.existsSync(typesRoot)) return;
-  for (const name of fs7.readdirSync(typesRoot)) {
+  if (!fs8.existsSync(typesRoot)) return;
+  for (const name of fs8.readdirSync(typesRoot)) {
     if (name.startsWith(`.fg-staging-${alias}-`) || name.startsWith(`.fg-trash-${alias}-`)) {
-      fs7.rmSync(path6.join(typesRoot, name), { recursive: true, force: true });
+      fs8.rmSync(path8.join(typesRoot, name), { recursive: true, force: true });
     }
   }
 }
@@ -3002,7 +4707,7 @@ async function syncRemoteTypes(input) {
   const fetchJsonFn = input.fetchJsonImpl ?? fetchJson;
   const fetchTextFn = input.fetchTextImpl ?? fetchText;
   const timeoutMs = input.timeoutMs ?? 15e3;
-  const dir = path6.join(typesRoot, alias);
+  const dir = path8.join(typesRoot, alias);
   let manifest;
   try {
     const parsed = parseManifest(await fetchJsonFn(manifestUrl, timeoutMs));
@@ -3015,7 +4720,7 @@ async function syncRemoteTypes(input) {
     }
     manifest = parsed.manifest;
   } catch (e) {
-    const meta = fs7.existsSync(dir) ? readMetadata(dir) : null;
+    const meta = fs8.existsSync(dir) ? readMetadata(dir) : null;
     return {
       status: "failed",
       alias,
@@ -3025,7 +4730,7 @@ async function syncRemoteTypes(input) {
   }
   const types = readManifestTypes(manifest);
   if (!types) {
-    const meta = fs7.existsSync(dir) ? readMetadata(dir) : null;
+    const meta = fs8.existsSync(dir) ? readMetadata(dir) : null;
     if (isDevManifest(manifest) && manifest.typesPending === true) {
       return {
         status: meta ? "stale" : "failed",
@@ -3045,7 +4750,7 @@ async function syncRemoteTypes(input) {
     };
   }
   const indexUrl = new URL(types.index, manifestUrl).toString();
-  const existing = fs7.existsSync(dir) ? readMetadata(dir) : null;
+  const existing = fs8.existsSync(dir) ? readMetadata(dir) : null;
   if (existing && existing.revision === types.revision && existing.ambientFormat === AMBIENT_FORMAT) {
     return { status: "unchanged", alias, revision: types.revision, message: `\u8FDC\u7A0B ${alias} \u7C7B\u578B\u5DF2\u662F\u6700\u65B0\uFF08revision ${types.revision}\uFF09\u3002` };
   }
@@ -3103,15 +4808,15 @@ async function syncRemoteTypes(input) {
   }
   const ambient = buildAmbientDeclarations({ alias, index, readFile: (rel) => indexRaw[rel] ?? "", source });
   sweepStaleStaging(typesRoot, alias);
-  const staging = path6.join(typesRoot, `.fg-staging-${alias}-${process.pid}-${Date.now()}`);
-  fs7.rmSync(staging, { recursive: true, force: true });
-  fs7.mkdirSync(staging, { recursive: true });
+  const staging = path8.join(typesRoot, `.fg-staging-${alias}-${process.pid}-${Date.now()}`);
+  fs8.rmSync(staging, { recursive: true, force: true });
+  fs8.mkdirSync(staging, { recursive: true });
   const written = [];
   try {
     for (const [name, content] of ambient.files) {
-      const dest = path6.join(staging, name);
-      fs7.mkdirSync(path6.dirname(dest), { recursive: true });
-      fs7.writeFileSync(dest, content);
+      const dest = path8.join(staging, name);
+      fs8.mkdirSync(path8.dirname(dest), { recursive: true });
+      fs8.writeFileSync(dest, content);
       written.push(name);
     }
     const meta = {
@@ -3124,22 +4829,22 @@ async function syncRemoteTypes(input) {
       externals: index.externals,
       syncedAt: Date.now()
     };
-    fs7.writeFileSync(path6.join(staging, METADATA_FILE), JSON.stringify(meta, null, 2));
-    const trash = path6.join(typesRoot, `.fg-trash-${alias}-${Date.now()}`);
+    fs8.writeFileSync(path8.join(staging, METADATA_FILE), JSON.stringify(meta, null, 2));
+    const trash = path8.join(typesRoot, `.fg-trash-${alias}-${Date.now()}`);
     let swapped = false;
-    if (fs7.existsSync(dir)) {
-      fs7.renameSync(dir, trash);
+    if (fs8.existsSync(dir)) {
+      fs8.renameSync(dir, trash);
       swapped = true;
     }
     try {
-      fs7.renameSync(staging, dir);
+      fs8.renameSync(staging, dir);
     } catch (e) {
-      if (swapped) fs7.renameSync(trash, dir);
+      if (swapped) fs8.renameSync(trash, dir);
       throw e;
     }
-    if (swapped) fs7.rmSync(trash, { recursive: true, force: true });
+    if (swapped) fs8.rmSync(trash, { recursive: true, force: true });
   } catch (e) {
-    fs7.rmSync(staging, { recursive: true, force: true });
+    fs8.rmSync(staging, { recursive: true, force: true });
     return { status: "failed", alias, message: `\u8FDC\u7A0B ${alias} \u7684\u7C7B\u578B\u5199\u5165\u5931\u8D25\uFF08${e.message}\uFF09\u3002\u672C\u5730\u58F0\u660E\u4FDD\u6301\u539F\u72B6\u3002` };
   }
   return {
@@ -3169,16 +4874,16 @@ __export(dts_cli_exports, {
   hostTypesRoot: () => hostTypesRoot,
   runTypesCommand: () => runTypesCommand
 });
-import fs8 from "node:fs";
-import path7 from "node:path";
-import { createRequire as createRequire4 } from "node:module";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { createRequire as createRequire5 } from "node:module";
 function hostTypesRoot(root, dtsDirOverride) {
-  if (dtsDirOverride) return path7.resolve(root, dtsDirOverride);
-  return path7.join(root, fs8.existsSync(path7.join(root, "src")) ? "src/fulgurjs/types" : ".fulgurjs/types");
+  if (dtsDirOverride) return path9.resolve(root, dtsDirOverride);
+  return path9.join(root, fs9.existsSync(path9.join(root, "src")) ? "src/fulgurjs/types" : ".fulgurjs/types");
 }
 async function runTypesCommand(opts) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = path7.resolve(cwd, opts.configPath ?? "fulgurjs.config.ts");
+  const configPath = path9.resolve(cwd, opts.configPath ?? "fulgurjs.config.ts");
   const lines = [];
   let failed = false;
   let cfg;
@@ -3187,16 +4892,16 @@ async function runTypesCommand(opts) {
   } catch (e) {
     return { exitCode: 2, lines: [String(e.message ?? e)] };
   }
-  const root = path7.dirname(configPath);
+  const root = path9.dirname(configPath);
   const mode = opts.mode ?? "dev";
-  const n = normalizeOptions(cfg.options, root, mode === "dev" ? "serve" : "build");
-  const dtsEnabled = n.dts !== false;
+  const n2 = normalizeOptions(cfg.options, root, mode === "dev" ? "serve" : "build");
+  const dtsEnabled = n2.dts !== false;
   if (!dtsEnabled) {
     lines.push(`dts: false\u2014\u2014\u672C\u5DE5\u7A0B\u4E3B\u52A8\u5173\u95ED\u8FDC\u7A0B\u7C7B\u578B\u652F\u6301\uFF0Ctypes \u547D\u4EE4\u4E0D\u6267\u884C\u4EFB\u4F55\u751F\u6210\u6216\u540C\u6B65\u3002`);
     return { exitCode: 0, lines };
   }
-  const typesRoot = hostTypesRoot(root, typeof n.dts === "object" ? n.dts.dir : void 0);
-  const publicExposes = n.exposes.filter((e) => !e.internal);
+  const typesRoot = hostTypesRoot(root, typeof n2.dts === "object" ? n2.dts.dir : void 0);
+  const publicExposes = n2.exposes.filter((e) => !e.internal);
   if (publicExposes.length > 0) {
     const result = await generateTypesBundle({
       root,
@@ -3213,10 +4918,10 @@ async function runTypesCommand(opts) {
       for (const d of result.diagnostics) lines.push(`  ${d.replaceAll("\n", "\n  ")}`);
     }
   }
-  const syncable = n.remotes.filter((r) => !r.promise && (mode === "dev" ? r.devEntry : r.prodEntry));
+  const syncable = n2.remotes.filter((r) => !r.promise && (mode === "dev" ? r.devEntry : r.prodEntry));
   if (opts.check) {
-    for (const remote of n.remotes) {
-      const meta = readMetadata(path7.join(typesRoot, remote.key));
+    for (const remote of n2.remotes) {
+      const meta = readMetadata(path9.join(typesRoot, remote.key));
       if (!meta) {
         failed = true;
         lines.push(`[check] \u8FDC\u7A0B ${remote.key}\uFF1A\u672C\u5730\u65E0\u5DF2\u540C\u6B65\u7C7B\u578B\uFF08\u5148\u8FD0\u884C fulgurjs types\uFF09\u3002`);
@@ -3227,7 +4932,7 @@ async function runTypesCommand(opts) {
     return { exitCode: failed ? 1 : 0, lines };
   }
   if (syncable.length > 0) {
-    lines.push(`[consumer] \u5F00\u59CB\u540C\u6B65 ${syncable.length} \u4E2A\u8FDC\u7A0B\u7684\u7C7B\u578B\uFF08--mode ${mode}\uFF0C\u76EE\u5F55 ${path7.relative(root, typesRoot) || typesRoot}\uFF09\u2026\u2026`);
+    lines.push(`[consumer] \u5F00\u59CB\u540C\u6B65 ${syncable.length} \u4E2A\u8FDC\u7A0B\u7684\u7C7B\u578B\uFF08--mode ${mode}\uFF0C\u76EE\u5F55 ${path9.relative(root, typesRoot) || typesRoot}\uFF09\u2026\u2026`);
     const externalsMissing = /* @__PURE__ */ new Map();
     for (const remote of syncable) {
       const entry = mode === "dev" ? remote.devEntry : remote.prodEntry;
@@ -3250,7 +4955,7 @@ async function runTypesCommand(opts) {
       if (result.status === "absent") {
         failed = true;
       }
-      const meta = readMetadata(path7.join(typesRoot, remote.key));
+      const meta = readMetadata(path9.join(typesRoot, remote.key));
       if (meta) {
         for (const ext of meta.externals) {
           if (!resolvePackage(root, ext)) {
@@ -3284,11 +4989,11 @@ async function runTypesCommand(opts) {
 }
 function resolvePackage(root, pkg) {
   try {
-    createRequire4(path7.join(root, "package.json")).resolve(`${pkg}/package.json`);
+    createRequire5(path9.join(root, "package.json")).resolve(`${pkg}/package.json`);
     return true;
   } catch {
     try {
-      createRequire4(path7.join(root, "package.json")).resolve(pkg);
+      createRequire5(path9.join(root, "package.json")).resolve(pkg);
       return true;
     } catch {
       return false;
@@ -3314,16 +5019,16 @@ __export(port_exports, {
   formatPortPlan: () => formatPortPlan,
   planPortChange: () => planPortChange
 });
-import fs9 from "node:fs";
-import path8 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 function readDevConfig2(root) {
-  const file = path8.join(root, "scripts", "dev.config.json");
-  if (!fs9.existsSync(file)) {
+  const file = path10.join(root, "scripts", "dev.config.json");
+  if (!fs10.existsSync(file)) {
     throw new Error(
       "[fulgurjs:port] \u672A\u627E\u5230 scripts/dev.config.json\u2014\u2014\u672C\u547D\u4EE4\u7528\u4E8E\u6A21\u677F\u5DE5\u7A0B\uFF08create \u751F\u6210\uFF09\u3002\n  \u4FEE\u6CD5\uFF1A\u5728\u6A21\u677F\u5DE5\u7A0B\u6839\u76EE\u5F55\u8FD0\u884C\uFF1B\u81EA\u5EFA\u5DE5\u7A0B\u8BF7\u6309\u6587\u6863\u56DB\u5904\u6E05\u5355\u624B\u5DE5\u6539\u7AEF\u53E3"
     );
   }
-  return JSON.parse(fs9.readFileSync(file, "utf8"));
+  return JSON.parse(fs10.readFileSync(file, "utf8"));
 }
 function replacePort(text, from, to) {
   const re = new RegExp(`(?<![0-9])${from}(?![0-9])`, "g");
@@ -3348,23 +5053,23 @@ function planPortChange(root, app, to) {
   }
   const notes = [];
   const candidates = [
-    { file: path8.join(root, target.dir, "package.json"), required: true },
-    { file: path8.join(root, "scripts", "dev.config.json"), required: true },
-    { file: path8.join(root, "fulgurjs.config.ts"), required: false },
-    { file: path8.join(root, "README.md"), required: false }
+    { file: path10.join(root, target.dir, "package.json"), required: true },
+    { file: path10.join(root, "scripts", "dev.config.json"), required: true },
+    { file: path10.join(root, "fulgurjs.config.ts"), required: false },
+    { file: path10.join(root, "README.md"), required: false }
   ];
   for (const a of cfg.apps) {
     if (a.host && a.dir !== target.dir) {
-      candidates.push({ file: path8.join(root, a.dir, "fulgurjs.config.ts"), required: false });
+      candidates.push({ file: path10.join(root, a.dir, "fulgurjs.config.ts"), required: false });
     }
   }
   const plans = [];
   for (const c of candidates) {
-    if (!fs9.existsSync(c.file)) {
+    if (!fs10.existsSync(c.file)) {
       if (c.required) plans.push({ file: c.file, hits: 0, status: "missing-file" });
       continue;
     }
-    const text = fs9.readFileSync(c.file, "utf8");
+    const text = fs10.readFileSync(c.file, "utf8");
     const { hits } = replacePort(text, from, to);
     plans.push({ file: c.file, hits, status: hits > 0 ? "planned" : "not-found" });
   }
@@ -3375,7 +5080,7 @@ function planPortChange(root, app, to) {
   }
   const notFound = plans.filter((p) => p.status === "not-found" || p.status === "missing-file");
   if (notFound.length) {
-    notes.push(`\u4EE5\u4E0B\u6587\u4EF6\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${from}\uFF08\u53EF\u80FD\u5DF2\u6539\u6216\u5F62\u6001\u4E0D\u540C\uFF0C\u8BF7\u4EBA\u5DE5\u786E\u8BA4\uFF09\uFF1A${notFound.map((p) => path8.relative(root, p.file)).join("\u3001")}`);
+    notes.push(`\u4EE5\u4E0B\u6587\u4EF6\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${from}\uFF08\u53EF\u80FD\u5DF2\u6539\u6216\u5F62\u6001\u4E0D\u540C\uFF0C\u8BF7\u4EBA\u5DE5\u786E\u8BA4\uFF09\uFF1A${notFound.map((p) => path10.relative(root, p.file)).join("\u3001")}`);
   }
   return { app: target.name, dir: target.dir, from, to, plans, notes };
 }
@@ -3383,10 +5088,10 @@ function applyPortChange(root, plan) {
   let written = 0;
   for (const p of plan.plans) {
     if (p.status !== "planned" || p.hits === 0) continue;
-    const text = fs9.readFileSync(p.file, "utf8");
+    const text = fs10.readFileSync(p.file, "utf8");
     const { text: out, hits } = replacePort(text, plan.from, plan.to);
     if (hits > 0) {
-      fs9.writeFileSync(p.file, out);
+      fs10.writeFileSync(p.file, out);
       written++;
     }
   }
@@ -3396,12 +5101,12 @@ function formatPortPlan(root, plan) {
   const lines = [];
   lines.push(`[fulgurjs:port] \u8BA1\u5212\uFF1A${plan.app}\uFF08\u76EE\u5F55 ${plan.dir}\uFF09\u7AEF\u53E3 ${plan.from} \u2192 ${plan.to}`);
   for (const p of plan.plans) {
-    const rel = path8.relative(root, p.file);
+    const rel = path10.relative(root, p.file);
     if (p.status === "planned") lines.push(`  \u6539\u5199 ${rel}\uFF08${p.hits} \u5904\uFF09`);
     else if (p.status === "not-found") lines.push(`  \u8DF3\u8FC7 ${rel}\uFF08\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${plan.from}\uFF09`);
     else lines.push(`  \u8DF3\u8FC7 ${rel}\uFF08\u6587\u4EF6\u4E0D\u5B58\u5728\uFF09`);
   }
-  for (const n of plan.notes) lines.push(`  \u6CE8\uFF1A${n}`);
+  for (const n2 of plan.notes) lines.push(`  \u6CE8\uFF1A${n2}`);
   lines.push("\u9884\u89C8\u6A21\u5F0F\u672A\u5199\u76D8\uFF1B\u786E\u8BA4\u65E0\u8BEF\u540E\u52A0 --write \u6267\u884C\u3002\u5199\u5165\u53EF\u7528 git checkout <file> \u56DE\u9000\u3002");
   return lines.join("\n");
 }
@@ -3411,69 +5116,14 @@ var init_port = __esm({
   }
 });
 
-// node_modules/es-module-lexer/dist/lexer.js
-function parse(E2, g = "@") {
-  if (!C) return init.then((() => parse(E2)));
-  const I = E2.length + 1, w = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
-  w > 0 && C.memory.grow(Math.ceil(w / 65536));
-  const K = C.sa(I - 1);
-  if ((A ? B : Q)(E2, new Uint16Array(C.memory.buffer, K, I)), !C.parse()) throw Object.assign(new Error(`Parse error ${g}:${E2.slice(0, C.e()).split("\n").length}:${C.e() - E2.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
-  const o = [], D = [];
-  for (; C.ri(); ) {
-    const A2 = C.is(), Q2 = C.ie(), B2 = C.it(), g2 = C.ai(), I2 = C.id(), w2 = C.ss(), K2 = C.se();
-    let D2;
-    C.ip() && (D2 = k(E2.slice(-1 === I2 ? A2 - 1 : A2, -1 === I2 ? Q2 + 1 : Q2))), o.push({ n: D2, t: B2, s: A2, e: Q2, ss: w2, se: K2, d: I2, a: g2 });
-  }
-  for (; C.re(); ) {
-    const A2 = C.es(), Q2 = C.ee(), B2 = C.els(), g2 = C.ele(), I2 = E2.slice(A2, Q2), w2 = I2[0], K2 = B2 < 0 ? void 0 : E2.slice(B2, g2), o2 = K2 ? K2[0] : "";
-    D.push({ s: A2, e: Q2, ls: B2, le: g2, n: '"' === w2 || "'" === w2 ? k(I2) : I2, ln: '"' === o2 || "'" === o2 ? k(K2) : K2 });
-  }
-  function k(A2) {
-    try {
-      return (0, eval)(A2);
-    } catch (A3) {
-    }
-  }
-  return [o, D, !!C.f(), !!C.ms()];
-}
-function Q(A2, Q2) {
-  const B2 = A2.length;
-  let C2 = 0;
-  for (; C2 < B2; ) {
-    const B3 = A2.charCodeAt(C2);
-    Q2[C2++] = (255 & B3) << 8 | B3 >>> 8;
-  }
-}
-function B(A2, Q2) {
-  const B2 = A2.length;
-  let C2 = 0;
-  for (; C2 < B2; ) Q2[C2] = A2.charCodeAt(C2++);
-}
-var ImportType, A, C, E, init;
-var init_lexer = __esm({
-  "node_modules/es-module-lexer/dist/lexer.js"() {
-    !(function(A2) {
-      A2[A2.Static = 1] = "Static", A2[A2.Dynamic = 2] = "Dynamic", A2[A2.ImportMeta = 3] = "ImportMeta", A2[A2.StaticSourcePhase = 4] = "StaticSourcePhase", A2[A2.DynamicSourcePhase = 5] = "DynamicSourcePhase", A2[A2.StaticDeferPhase = 6] = "StaticDeferPhase", A2[A2.DynamicDeferPhase = 7] = "DynamicDeferPhase";
-    })(ImportType || (ImportType = {}));
-    A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
-    E = () => {
-      return A2 = "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", "undefined" != typeof Buffer ? Buffer.from(A2, "base64") : Uint8Array.from(atob(A2), ((A3) => A3.charCodeAt(0)));
-      var A2;
-    };
-    init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({ exports: A2 }) => {
-      C = A2;
-    }));
-  }
-});
-
 // src/doctor-source.ts
 var doctor_source_exports = {};
 __export(doctor_source_exports, {
   runSourceDoctor: () => runSourceDoctor
 });
-import fs10 from "node:fs";
-import path9 from "node:path";
-import { createRequire as createRequire5 } from "node:module";
+import fs11 from "node:fs";
+import path11 from "node:path";
+import { createRequire as createRequire6 } from "node:module";
 async function runSourceDoctor(configPath) {
   let loaded;
   try {
@@ -3497,7 +5147,7 @@ async function runSourceDoctor(configPath) {
       integrationFiles: { required: [], optional: [], existing: [] }
     };
   }
-  const root = fs10.realpathSync(loaded.appRoot);
+  const root = fs11.realpathSync(loaded.appRoot);
   const options = loaded.options;
   const app = options.name;
   const checks = [];
@@ -3506,23 +5156,36 @@ async function runSourceDoctor(configPath) {
   const imports = /* @__PURE__ */ new Set();
   const sources = /* @__PURE__ */ new Map();
   let complete = true;
-  const relative = (file) => path9.relative(root, file).split(path9.sep).join("/");
-  const within = (file) => file === root || file.startsWith(root + path9.sep);
+  const relative = (file) => path11.relative(root, file).split(path11.sep).join("/");
+  const within = (file) => file === root || file.startsWith(root + path11.sep);
   const add = (item, level, symptom, cause, fix) => {
     checks.push({ app, item, level, symptom, cause, fix });
   };
   const resolveSource = (value, parent = root) => {
     const clean = value.split(/[?#]/)[0];
-    const file = /^(?:\/?@\/|~\/)/.test(clean) ? path9.join(root, "src", clean.replace(/^(?:\/?@\/|~\/)/, "")) : path9.resolve(parent, clean);
+    const file = /^(?:\/?@\/|~\/)/.test(clean) ? path11.join(root, "src", clean.replace(/^(?:\/?@\/|~\/)/, "")) : path11.resolve(parent, clean);
     for (const ext of extensions) {
       const candidate = file + ext;
-      if (!fs10.existsSync(candidate) || !fs10.statSync(candidate).isFile()) continue;
-      const real = fs10.realpathSync(candidate);
+      if (!fs11.existsSync(candidate) || !fs11.statSync(candidate).isFile()) continue;
+      const real = fs11.realpathSync(candidate);
       return real;
     }
     return void 0;
   };
   const required = [relative(loaded.configPath)];
+  const viteFiles = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"].filter((file) => fs11.existsSync(path11.join(root, file)));
+  if (viteFiles.length !== 1) add("Vite \u63D2\u4EF6\u63A5\u7EBF", "WARN", "\u672A\u627E\u5230\u552F\u4E00\u5E38\u89C4 Vite \u914D\u7F6E\uFF0C\u65E0\u6CD5\u786E\u8BA4\u63D2\u4EF6\u6CE8\u518C\u3002", "\u53EF\u80FD\u4F7F\u7528\u81EA\u5B9A\u4E49 --config \u6216\u591A\u4EFD\u73AF\u5883\u914D\u7F6E\u3002", "\u5728\u5B9E\u9645 Vite plugins \u4E2D\u6CE8\u518C federation(fulgurjsConfig)\uFF1Binit --plan \u53EF\u9884\u89C8\u53D7\u652F\u6301\u914D\u7F6E\u7684\u63A5\u7EBF\u3002");
+  else {
+    const code = fs11.readFileSync(path11.join(root, viteFiles[0]), "utf8");
+    add(
+      viteFiles[0],
+      "WARN",
+      "Vite \u914D\u7F6E\u5B58\u5728\uFF1B\u63D2\u4EF6\u8C03\u7528\u3001\u52A8\u6001 base \u4E0E\u90E8\u7F72\u5BF9\u5E94\u5173\u7CFB\u4ECD\u9700\u6838\u5BF9\u3002",
+      "\u672C\u5730\u9884\u68C0\u4E0D\u6267\u884C Vite \u914D\u7F6E\uFF1B\u5BFC\u5165\u63D2\u4EF6\u6216\u5199\u4E86\u6CE8\u91CA\u5E76\u4E0D\u80FD\u8BC1\u660E plugins \u5B9E\u9645\u542F\u7528\u3002",
+      code.includes("@fulgurjs/federation") ? "\u8FD0\u884C\u771F\u5B9E dev/build\uFF1B\u786E\u8BA4\u5F53\u524D\u914D\u7F6E\u8C03\u7528 federation\uFF0C\u751F\u4EA7 base/\u8FDC\u7A0B prod \u524D\u7F00\u4E0E\u670D\u52A1\u5668\u6620\u5C04\u4E00\u81F4\u3002" : "\u68C0\u67E5\u63D2\u4EF6\u662F\u5426\u7531\u8F85\u52A9\u51FD\u6570\u6CE8\u518C\uFF1B\u5426\u5219\u7528 init --plan \u9884\u89C8\u63A5\u7EBF\uFF0C\u4E0D\u8981\u4EC5\u521B\u5EFA fulgurjs.config.ts\u3002"
+    );
+  }
+  if (fs11.existsSync(path11.join(root, ".fulgurjs-init-pending.json"))) add("\u63A5\u5165\u5199\u5165\u6062\u590D", "FAIL", "\u5B58\u5728\u88AB\u4E2D\u65AD\u7684 init \u5199\u5165\u8BB0\u5F55\u3002", "\u6B64\u524D\u5199\u5165\u5C1A\u672A\u5B8C\u6210\u6216\u56DE\u9000\u9047\u5230\u624B\u5DE5\u7F16\u8F91\u3002", "\u8FD0\u884C fulgurjs init --rollback\uFF1B\u82E5\u63D0\u793A\u6587\u4EF6\u88AB\u7F16\u8F91\uFF0C\u6309\u6062\u590D\u8BB0\u5F55\u4EBA\u5DE5\u5408\u5E76\u540E\u518D\u6267\u884C\u3002");
   for (const [key, expose] of Object.entries(options.exposes ?? {})) {
     const file = resolveSource(typeof expose === "string" ? expose : expose.import);
     if (file) {
@@ -3548,15 +5211,18 @@ async function runSourceDoctor(configPath) {
       add("setup", "FAIL", "setup \u6E90\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u89E3\u6790\u3002", "\u521D\u59CB\u5316\u5165\u53E3\u4E0D\u80FD\u5728\u52A0\u8F7D\u65F6\u624D\u53D1\u73B0\u7F3A\u5931\u3002", "\u4FEE\u6B63 setup \u8DEF\u5F84\uFF1B\u6CA1\u6709\u521D\u59CB\u5316\u9700\u6C42\u5219\u5220\u9664 setup \u914D\u7F6E\u3002");
     }
   }
-  const html = path9.join(root, "index.html");
+  const html = path11.join(root, "index.html");
   let hasEntry = false;
-  if (fs10.existsSync(html)) for (const tag of fs10.readFileSync(html, "utf8").matchAll(/<script\b[^>]*>/gi)) {
+  if (fs11.existsSync(html)) for (const tag of fs11.readFileSync(html, "utf8").matchAll(/<script\b[^>]*>/gi)) {
     const entry = tag[0].match(/\bsrc=["']([^"']+)["']/i)?.[1];
     if (!entry || !/\btype=["']module["']/i.test(tag[0]) || /^(?:https?:)?\/\//.test(entry)) continue;
     const file = resolveSource(entry.replace(/^\//, ""));
     if (file) {
       pending.push(file);
       hasEntry = true;
+    } else {
+      complete = false;
+      add("index.html \u5165\u53E3", "FAIL", `\u672C\u5730 module \u5165\u53E3\u4E0D\u5B58\u5728\uFF1A${entry}`, "\u5165\u53E3\u5F15\u7528\u65E0\u6CD5\u89E3\u6790\uFF0C\u4E0D\u80FD\u53EA\u68C0\u67E5 expose \u8DEF\u5F84\u3002", "\u4FEE\u6B63 index.html script src\uFF0C\u6216\u6062\u590D\u5B9E\u9645\u5165\u53E3\uFF1B\u81EA\u5B9A\u4E49\u865A\u62DF\u5165\u53E3\u4F7F\u7528\u5176\u63D2\u4EF6\u6784\u5EFA\u68C0\u67E5\u6838\u5B9E\u3002");
     }
   }
   if (Object.keys(options.remotes ?? {}).length && !hasEntry) complete = false;
@@ -3571,7 +5237,7 @@ async function runSourceDoctor(configPath) {
     if (seen.has(file) || /\.d\.[cm]?ts$/.test(file) || relative(file).includes("fulgurjs/types/")) continue;
     if (!/\.(?:[cm]?js|jsx|ts|tsx|vue)$/.test(file)) continue;
     seen.add(file);
-    const raw = fs10.readFileSync(file, "utf8");
+    const raw = fs11.readFileSync(file, "utf8");
     if (file.endsWith(".vue") && /<script\b[^>]*\bsrc\s*=/.test(raw)) complete = false;
     const script = file.endsWith(".vue") ? [...raw.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/gi)].map((match) => match[1]).join("\n") : raw;
     try {
@@ -3584,9 +5250,15 @@ async function runSourceDoctor(configPath) {
           continue;
         }
         imports.add(item.n);
+        if (/\.d\.[cm]?ts(?:[?#]|$)/.test(item.n)) {
+          add(relative(file), "FAIL", `\u8FD0\u884C\u65F6\u4EE3\u7801\u5BFC\u5165\u4E86\u7C7B\u578B\u58F0\u660E\uFF1A${item.n}`, "\u751F\u6210\u58F0\u660E\u4E0D\u662F\u53EF\u6267\u884C\u6A21\u5757\uFF0C\u4E0D\u80FD\u4F5C\u4E3A\u7EC4\u4EF6/\u5DE5\u5177\u8FD0\u884C\u65F6\u6CE8\u518C\u3002", "\u53EA\u4F7F\u7528 import type\uFF0C\u6216\u5F15\u7528\u771F\u6B63\u7684\u8FDC\u7A0B\u6A21\u5757\uFF1B\u68C0\u67E5 glob \u662F\u5426\u6392\u9664 **/*.d.ts\u3002");
+        }
+        if (item.n.startsWith("@fulgurjs/federation/") && !["@fulgurjs/federation/vue", "@fulgurjs/federation/react", "@fulgurjs/federation/runtime"].includes(item.n)) {
+          add(relative(file), "WARN", `\u5E94\u7528\u4EE3\u7801\u4F7F\u7528\u975E\u63A8\u8350\u5165\u53E3\uFF1A${item.n}`, "\u5185\u90E8\u6A21\u5757\u4E0D\u662F\u5E94\u7528\u63A5\u5165\u8DEF\u5F84\uFF1B\u9759\u6001\u9884\u68C0\u4E0D\u5224\u65AD\u8BE5\u8DEF\u5F84\u662F\u5426\u4ECD\u88AB exports \u5141\u8BB8\u3002", "Vue \u7528 /vue\uFF0CReact \u7528 /react\uFF0C\u6846\u67B6\u65E0\u5173\u6A21\u5757\u7528 /runtime\uFF1B\u7C7B\u578B\u6CE8\u518C\u8868\u7684 import type \u4E0D\u5E94\u6210\u4E3A\u8FD0\u884C\u65F6\u4EE3\u7801\u3002");
+        }
         if (item.n.startsWith(".") || /^(?:\/?@\/|~\/)/.test(item.n)) {
           if (/\.(?:[cm]?js|jsx|ts|tsx|vue)$/.test(item.n.split(/[?#]/)[0]) || !/\.[a-z0-9]+$/i.test(item.n.split(/[?#]/)[0])) {
-            const next = resolveSource(item.n, path9.dirname(file));
+            const next = resolveSource(item.n, path11.dirname(file));
             if (next) pending.push(next);
             else {
               complete = false;
@@ -3611,7 +5283,7 @@ async function runSourceDoctor(configPath) {
         "\u5728\u56DE\u8C03\u4E2D\u4F20\u5165\u672C\u5E94\u7528 pinia\uFF0C\u6216\u7528 /vue \u7684 bindStoreToApp \u7ED1\u5B9A\u5B9E\u9645\u5B9E\u4F8B\uFF1B\u7EC4\u4EF6\u5185\u4FDD\u7559\u539F\u751F\u6CE8\u5165\uFF0C\u4E0D\u628A\u5E93\u5355\u4F8B\u5F53\u6210\u4E1A\u52A1 store \u5B9E\u4F8B\u3002"
       );
     }
-    if (/defineBridgeApp\s*\(/.test(code) && /createWeb(?:Hash)?History\s*\(/.test(code) && !/createMemoryHistory|defineApplication/.test(code)) {
+    if (/define(?:BridgeApp|Application)\s*\(/.test(code) && /createWeb(?:Hash)?History\s*\(/.test(code) && !/createMemoryHistory/.test(code)) {
       add(
         file,
         "WARN",
@@ -3633,6 +5305,15 @@ async function runSourceDoctor(configPath) {
     }
   }
   const shared = Array.isArray(options.shared) ? options.shared : Object.keys(options.shared ?? {});
+  if (Object.keys(options.remotes ?? {}).length && options.dts !== false) {
+    add(
+      "\u8FDC\u7A0B\u7C7B\u578B\u63A5\u7EBF",
+      "WARN",
+      "\u8FDC\u7A0B\u7C7B\u578B\u542F\u7528\uFF1B\u672C\u5730\u626B\u63CF\u4E0D\u80FD\u8BC1\u660E\u58F0\u660E\u5DF2\u540C\u6B65\u4E14\u88AB IDE \u7684\u6709\u6548 tsconfig \u5305\u542B\u3002",
+      "\u9996\u6B21\u751F\u6210\u3001\u8FDC\u7A0B\u672A\u542F\u52A8\u3001\u81EA\u5B9A\u4E49 include/references \u6216 IDE \u9879\u76EE\u9009\u62E9\u90FD\u4F1A\u5F71\u54CD\u63D0\u793A\u3002",
+      "\u542F\u52A8\u63D0\u4F9B\u65B9\u540E\u8FD0\u884C fulgurjs types\uFF1B\u5728\u5B9E\u9645\u6D88\u8D39\u6587\u4EF6\u9A8C\u8BC1\u6B63\u786E props \u548C\u9519\u8BEF props \u7684\u6B63\u8D1F\u7C7B\u578B\u6837\u4F8B\u3002\u52FF\u7528 any \u6D88\u9664\u8BCA\u65AD\uFF0C\u4E5F\u65E0\u9700\u6E05\u7A7A\u5168\u90E8\u4E1A\u52A1\u5B58\u91CF\u9519\u8BEF\u3002"
+    );
+  }
   const isImported = (key) => [...imports].some((value) => value === key || value.startsWith(key + "/"));
   for (const key of shared) {
     const hint = Array.isArray(options.shared) ? void 0 : options.shared?.[key];
@@ -3696,7 +5377,7 @@ var init_doctor_source = __esm({
     "use strict";
     init_lexer();
     init_app_config();
-    requireFromHere = createRequire5(import.meta.url);
+    requireFromHere = createRequire6(import.meta.url);
     esbuildTransform = () => {
       if (!cachedTransform) {
         const esb = requireFromHere("esbuild");
@@ -3721,7 +5402,7 @@ function fetchHeadOrGet(url, method = "GET") {
     const req = mod.request(url, { method, headers: { accept: "*/*" } }, (res) => {
       const chunks = [];
       res.on("data", (c) => {
-        if (chunks.reduce((n, b) => n + b.length, 0) < 2 * 1024 * 1024) chunks.push(c);
+        if (chunks.reduce((n2, b) => n2 + b.length, 0) < 2 * 1024 * 1024) chunks.push(c);
       });
       res.on(
         "end",
@@ -4034,6 +5715,13 @@ var HELP = `fulgurjs \u2014 Vite Module Federation CLI (@fulgurjs/federation)
                                                    \u4FDD\u7559\u4F60\u7684\u7248\u672C\uFF08\u7EDD\u4E0D\u6539\u5199\uFF09\uFF1B--json \u65F6 stdout \u4EC5\u8F93\u51FA\u7ED3\u679C
                                                    JSON\uFF0C\u8FDB\u5EA6\u4E0E\u5B89\u88C5\u65E5\u5FD7\u8D70 stderr
 \u5DF2\u6709\u9879\u76EE\uFF08\u5355\u9879\u76EE fulgurjs.config.ts \u5728\u5E94\u7528\u6839\u76EE\u5F55\uFF1B\u547D\u4EE4\u9ED8\u8BA4\u8BFB ./fulgurjs.config.ts\uFF09\uFF1A
+  fulgurjs init --plan [--kind component|app] [--role consumer|provider|dual]
+                [--remote \u540D\u79F0=http://\u5F00\u53D1\u5730\u5740] [--expose ./\u952E=./\u6E90\u6587\u4EF6]
+                [--name \u5BB9\u5668\u540D] [--entry src/main.ts] [--framework vue|react] [--json]
+                                                 \u53EA\u626B\u63CF\u5E76\u9884\u89C8\u5B8C\u6574\u5DEE\u5F02\u4E0E\u4EBA\u5DE5\u5F85\u529E\uFF1B\u53EF\u91CD\u590D remote/expose\u3002
+                                                 --kind \u9ED8\u8BA4 component\uFF1Bapp \u652F\u6301\u7B80\u5355\u5165\u53E3\u63D0\u53D6\u4E0E\u5BBF\u4E3B\u89C6\u56FE\u3002
+                                                 --write \u663E\u5F0F\u5E94\u7528\uFF1B\u963B\u65AD\u9879\u5B58\u5728\u65F6\u6574\u6279\u4E0D\u5199\uFF0C\u4E0D\u8986\u76D6\u5DF2\u6709\u914D\u7F6E\u3002
+  fulgurjs init --rollback                         \u6062\u590D\u88AB\u4E2D\u65AD\u7684\u8BA1\u5212\u5199\u5165\uFF1B\u6709\u540E\u7EED\u4EBA\u5DE5\u7F16\u8F91\u65F6\u62D2\u7EDD\u8986\u76D6\u3002
   fulgurjs init [--out <\u8DEF\u5F84>] [--framework vue|react] [--role consumer|provider|dual] [--force]
                                                    \u751F\u6210\u5355\u9879\u76EE fulgurjs.config.ts \u8D77\u6B65\u6A21\u677F\uFF08\u6700\u5C0F\u6709\u6548\u914D\u7F6E\uFF09\uFF1A
                                                    \u6846\u67B6\u9ED8\u8BA4\u4ECE package.json \u4F9D\u8D56\u5224\u65AD\uFF08\u5224\u65AD\u4E0D\u4E86\u8981\u6C42\u663E\u5F0F --framework\uFF09\uFF1B
@@ -4104,6 +5792,63 @@ async function main() {
     return out;
   };
   if (cmd === "init") {
+    if (has("--rollback")) {
+      try {
+        if (argv.length !== 2) throw new Error("--rollback \u5FC5\u987B\u72EC\u7ACB\u4F7F\u7528\uFF0C\u4E0D\u4E0E\u5199\u5165\u6216\u9884\u89C8\u53C2\u6570\u6DF7\u7528\u3002");
+        const { rollbackIntegration: rollbackIntegration2 } = await Promise.resolve().then(() => (init_init_plan(), init_plan_exports));
+        rollbackIntegration2(process.cwd());
+        console.log("[fulgurjs:init] \u5DF2\u6062\u590D\u88AB\u4E2D\u65AD\u7684\u5199\u5165\uFF1B\u8BF7\u91CD\u65B0\u751F\u6210\u63A5\u5165\u9884\u89C8\u3002");
+        return 0;
+      } catch (error) {
+        console.error(String(error.message ?? error));
+        return 1;
+      }
+    }
+    if (has("--plan") || has("--write")) {
+      try {
+        if (has("--config") || has("--out") || has("--force")) throw new Error("\u63A5\u5165\u8BA1\u5212\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528 --config/--out/--force\uFF1B\u5DF2\u6709\u914D\u7F6E\u8BF7\u5355\u72EC\u8FD0\u884C doctor --config \u68C0\u67E5\u3002");
+        const values = ["--kind", "--role", "--framework", "--name", "--entry", "--remote", "--expose"];
+        for (let i = 1; i < argv.length; i++) {
+          if (["--plan", "--write", "--json"].includes(argv[i])) continue;
+          if (!values.includes(argv[i])) throw new Error(`\u672A\u77E5\u63A5\u5165\u8BA1\u5212\u53C2\u6570\uFF1A${argv[i]}`);
+          if (!argv[i + 1] || argv[i + 1].startsWith("--")) throw new Error(`${argv[i]} \u7F3A\u5C11\u503C`);
+          i++;
+        }
+        const kind = argOf("--kind") ?? "component";
+        const role = argOf("--role") ?? "dual";
+        const framework2 = argOf("--framework");
+        if (!["component", "app"].includes(kind) || !["consumer", "provider", "dual"].includes(role) || framework2 && !["vue", "react"].includes(framework2)) throw new Error("\u8BF7\u4F7F\u7528 --kind component|app\u3001--role consumer|provider|dual\u3001--framework vue|react\u3002");
+        const pairs = (flag) => {
+          const result2 = {};
+          argv.forEach((value, i) => {
+            if (value !== flag) return;
+            const pair = argv[i + 1], eq = pair?.indexOf("=") ?? -1;
+            if (eq < 1 || !pair.slice(eq + 1) || pair.startsWith("--")) throw new Error(`${flag} \u9700\u8981 \u952E=\u503C\uFF1B\u4E0D\u4F1A\u731C\u8FDC\u7A0B\u5730\u5740\u6216\u4E1A\u52A1\u6587\u4EF6\u3002`);
+            const key = pair.slice(0, eq);
+            if (Object.hasOwn(result2, key)) throw new Error(`${flag} \u91CD\u590D\u952E\uFF1A${key}`);
+            Object.defineProperty(result2, key, { value: pair.slice(eq + 1), enumerable: true, configurable: true });
+          });
+          return result2;
+        };
+        const { planIntegration: planIntegration2, formatIntegrationPlan: formatIntegrationPlan2, applyIntegration: applyIntegration2 } = await Promise.resolve().then(() => (init_init_plan(), init_plan_exports));
+        const plan = await planIntegration2({ cwd: process.cwd(), kind, role, framework: framework2, name: argOf("--name"), entry: argOf("--entry"), remotes: pairs("--remote"), exposes: pairs("--expose") });
+        const blocked = plan.tasks.some((task) => task.blocking);
+        if (has("--write") && !blocked) applyIntegration2(plan);
+        const written = has("--write") && !blocked;
+        if (has("--json")) console.log(JSON.stringify({ ...plan, written }, null, 2));
+        else console.log(formatIntegrationPlan2(plan) + (blocked ? "\n\u5B58\u5728\u963B\u65AD\u9879\uFF0C\u6574\u6279\u672A\u5199\u5165\uFF1B\u5148\u5904\u7406\u6240\u5217\u4E8B\u9879\u518D\u9884\u89C8\u3002" : written ? "\n\u5DF2\u5E94\u7528\u8BA1\u5212\uFF1B\u4EBA\u5DE5\u63A5\u7EBF\u4E0E\u771F\u5B9E\u6D4F\u89C8\u5668\u9A8C\u8BC1\u4ECD\u9700\u5B8C\u6210\u3002" : "\n\u786E\u8BA4\u4EE5\u4E0A\u5DEE\u5F02\u540E\uFF0C\u4F7F\u7528\u76F8\u540C\u53C2\u6570\u8FFD\u52A0 --write \u5E94\u7528\uFF1B\u5DE5\u5177\u4E0D\u81EA\u52A8\u5B89\u88C5\u4F9D\u8D56\u3002"));
+        return blocked ? 1 : 0;
+      } catch (error) {
+        const message = String(error.message ?? error);
+        if (has("--json")) console.log(JSON.stringify({ written: false, error: message }));
+        else console.error(`[fulgurjs:init] ${message}`);
+        return 1;
+      }
+    }
+    if (["--kind", "--remote", "--expose", "--entry", "--name"].some(has)) {
+      console.error("[fulgurjs:init] \u63A5\u5165\u8BA1\u5212\u53C2\u6570\u9700\u8981 --plan\uFF08\u9884\u89C8\uFF09\u6216 --write\uFF08\u663E\u5F0F\u5199\u5165\uFF09\u3002");
+      return 2;
+    }
     const { writeConfigTemplate: writeConfigTemplate2, inspectConfig: inspectConfig2, detectFrameworkFromPackageJson: detectFrameworkFromPackageJson2 } = await Promise.resolve().then(() => (init_init(), init_exports));
     const configPath = argOf("--config");
     if (configPath) {
@@ -4290,7 +6035,7 @@ async function main() {
       if (has("--write")) {
         const written = applyPortChange2(process.cwd(), plan);
         console.log(`[fulgurjs:port] \u5DF2\u5199\u5165 ${written} \u4E2A\u6587\u4EF6\uFF08${app} ${plan.from} \u2192 ${plan.to}\uFF09\u3002\u56DE\u9000\uFF1Agit checkout <file>`);
-        for (const n of plan.notes) console.log(`  \u6CE8\uFF1A${n}`);
+        for (const n2 of plan.notes) console.log(`  \u6CE8\uFF1A${n2}`);
       } else {
         console.log(formatPortPlan2(process.cwd(), plan));
       }