@adep/web-container 0.1.1 → 0.2.1

package/dist/web-container.iife.js

@@ -92,9 +92,796 @@ var AdepWebContainer = (() => {
     }
   });
 
-  // src/preview.ts
-  var preview_exports = {};
-  __export(preview_exports, {
+  // src/node-resolve.ts
+  function parsePackageMeta(content, context) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      throw new ResolveError(`${context} \u4E0D\u662F\u5408\u6CD5 JSON`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new ResolveError(`${context} \u9876\u5C42\u5FC5\u987B\u662F\u5BF9\u8C61`);
+    }
+    return parsed;
+  }
+  function withinPackage(pkgDirAbs, rel, context) {
+    if (typeof rel !== "string" || rel === "") {
+      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84\u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    }
+    if (!rel.startsWith("./") && !rel.startsWith("../") && rel.startsWith("/")) {
+      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84 "${rel}" \u5FC5\u987B\u662F\u5305\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF08\u4EE5 ./ \u5F00\u5934\uFF09`);
+    }
+    const abs = join(pkgDirAbs, rel.startsWith(".") ? rel : `./${rel}`);
+    if (!abs.startsWith(`${pkgDirAbs}/`)) {
+      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84 "${rel}" \u8D8A\u51FA\u5305\u76EE\u5F55\uFF0C\u5DF2\u62D2\u7EDD`);
+    }
+    return abs;
+  }
+  function resolvePackageEntry(meta, pkgDirAbs, condition) {
+    const context = `\u5305 ${meta.name ?? meta.version ?? pkgDirAbs} \u7684 exports/main \u58F0\u660E`;
+    const exp = meta.exports;
+    if (exp !== void 0 && exp !== null) {
+      if (typeof exp === "string") return withinPackage(pkgDirAbs, exp, context);
+      if (typeof exp !== "object" || Array.isArray(exp)) {
+        throw new ResolveError(`${context} \u5F62\u6001\u4E0D\u652F\u6301\uFF08exports \u53EA\u80FD\u662F\u5B57\u7B26\u4E32\u6216\u5BF9\u8C61\uFF09`);
+      }
+      const dot = exp["."];
+      if (dot === void 0) {
+        throw new ResolveError(
+          `${context} \u53EA\u58F0\u660E\u4E86\u5B50\u8DEF\u5F84\u6620\u5C04\u3001\u6CA1\u6709 "." \u5165\u53E3\uFF0C\u5F53\u524D\u4EC5\u652F\u6301 "." \u4E0E\u5B57\u7B26\u4E32\u5F62\u6001`
+        );
+      }
+      if (typeof dot === "string") return withinPackage(pkgDirAbs, dot, context);
+      if (dot === null)
+        throw new ResolveError(`${context}\uFF1Aexports["."] \u4E3A null\uFF08\u8BE5\u6761\u4EF6\u88AB\u663E\u5F0F\u6392\u9664\uFF09\uFF0C\u65E0\u6CD5\u89E3\u6790\u5165\u53E3`);
+      if (typeof dot !== "object" || Array.isArray(dot)) {
+        throw new ResolveError(`${context}\uFF1Aexports["."] \u5F62\u6001\u4E0D\u652F\u6301\uFF08\u4EC5\u63A5\u53D7\u5B57\u7B26\u4E32\u6216\u6761\u4EF6\u5BF9\u8C61\uFF09`);
+      }
+      const conditions = dot;
+      const order = condition === "import" ? ["import", "node", "default"] : ["require", "node", "default"];
+      for (const key of order) {
+        const value = conditions[key];
+        if (typeof value === "string") return withinPackage(pkgDirAbs, value, context);
+        if (value !== void 0 && (typeof value !== "object" || value === null)) {
+          throw new ResolveError(
+            `${context}\uFF1Aexports["."]["${key}"] \u5F62\u6001\u4E0D\u652F\u6301\uFF08\u4EC5\u63A5\u53D7\u5B57\u7B26\u4E32\u6216 null\uFF09`
+          );
+        }
+      }
+      throw new ResolveError(
+        `${context}\uFF1Aexports["."] \u6761\u4EF6\u5BF9\u8C61\u91CC\u6CA1\u6709 ${condition}/node/default \u5B57\u7B26\u4E32\u5165\u53E3\uFF08\u5B50\u8DEF\u5F84/\u5D4C\u5957\u6761\u4EF6\u4E0D\u652F\u6301\uFF09`
+      );
+    }
+    if (meta.main !== void 0) {
+      if (typeof meta.main !== "string") {
+        throw new ResolveError(`${context}\uFF1Amain \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+      }
+      return withinPackage(pkgDirAbs, meta.main, context);
+    }
+    return join(pkgDirAbs, "index.js");
+  }
+  function splitPackageSpecifier(spec) {
+    if (spec.startsWith("@")) {
+      const first = spec.indexOf("/");
+      if (first === -1) return { name: spec, subpath: "" };
+      const second = spec.indexOf("/", first + 1);
+      if (second === -1) return { name: spec, subpath: "" };
+      return { name: spec.slice(0, second), subpath: spec.slice(second + 1) };
+    }
+    const slash = spec.indexOf("/");
+    if (slash === -1) return { name: spec, subpath: "" };
+    return { name: spec.slice(0, slash), subpath: spec.slice(slash + 1) };
+  }
+  function asFile(fs, baseAbs) {
+    if (fs.exists(baseAbs) && !fsIsDirectory(fs, baseAbs)) return baseAbs;
+    for (const ext of RESOLVE_EXTENSIONS) {
+      const candidate = `${baseAbs}${ext}`;
+      if (fs.exists(candidate) && !fsIsDirectory(fs, candidate)) return candidate;
+    }
+    return null;
+  }
+  function asDirectory(fs, dirAbs) {
+    if (!fs.exists(dirAbs) || !fsIsDirectory(fs, dirAbs)) return null;
+    const manifest = `${dirAbs}/package.json`;
+    if (fs.exists(manifest)) {
+      const meta = parsePackageMeta(fs.readFile(manifest), manifest);
+      const entry = resolvePackageEntry(meta, dirAbs, "require");
+      const hit = asFile(fs, entry);
+      if (hit !== null) return hit;
+    }
+    return asFile(fs, join(dirAbs, "index"));
+  }
+  function fsIsDirectory(fs, path) {
+    const probe = fs;
+    return probe.isDirectory?.(path) ?? false;
+  }
+  function resolveImport(fs, specifier, fromFileAbs, condition = "require") {
+    if (specifier === "") throw new ResolveError("\u7A7A\u8BF4\u660E\u7B26\uFF1A\u65E0\u6CD5\u89E3\u6790\u6A21\u5757");
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      const base = join(dirname(fromFileAbs), specifier);
+      const hit = asFile(fs, base) ?? asDirectory(fs, base);
+      if (hit === null) {
+        throw new ResolveError(
+          `\u627E\u4E0D\u5230\u76F8\u5BF9\u6A21\u5757 "${specifier}"\uFF08\u81EA ${dirname(fromFileAbs)}\uFF0C\u8BD5\u8FC7\u6269\u5C55\u540D ${RESOLVE_EXTENSIONS.join("/")} \u4E0E\u76EE\u5F55\u7D22\u5F15\uFF09`
+        );
+      }
+      return hit;
+    }
+    if (specifier.startsWith("/")) {
+      const hit = asFile(fs, specifier) ?? asDirectory(fs, specifier);
+      if (hit === null) throw new ResolveError(`\u627E\u4E0D\u5230\u7EDD\u5BF9\u8DEF\u5F84\u6A21\u5757 "${specifier}"`);
+      return hit;
+    }
+    const { name, subpath } = splitPackageSpecifier(specifier);
+    if (name.startsWith("node:")) {
+      throw new ResolveError(`\u6D4F\u89C8\u5668\u6C99\u7BB1\u4E0D\u63D0\u4F9B Node \u5185\u5EFA\u6A21\u5757 "${specifier}"`);
+    }
+    let dir = dirname(fromFileAbs);
+    for (; ; ) {
+      const pkgDir = join(dir, "node_modules", name);
+      if (fs.exists(pkgDir) && fsIsDirectory(fs, pkgDir)) {
+        if (subpath === "") {
+          const manifest = `${pkgDir}/package.json`;
+          if (fs.exists(manifest)) {
+            const meta = parsePackageMeta(fs.readFile(manifest), manifest);
+            const entry = resolvePackageEntry(meta, pkgDir, condition);
+            const hit = asFile(fs, entry) ?? asDirectory(fs, entry);
+            if (hit !== null) return hit;
+          } else {
+            const hit = asFile(fs, join(pkgDir, "index")) ?? asDirectory(fs, pkgDir);
+            if (hit !== null) return hit;
+          }
+        } else {
+          const base = join(pkgDir, subpath);
+          const hit = asFile(fs, base) ?? asDirectory(fs, base);
+          if (hit !== null) return hit;
+        }
+        throw new ResolveError(
+          `\u5728 ${pkgDir} \u627E\u5230\u4E86\u5305 "${name}"\uFF0C\u4F46\u89E3\u6790\u8BF4\u660E\u7B26 "${specifier}" \u5931\u8D25\uFF08\u5B50\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF0C\u6216 exports/main \u6307\u5411\u7684\u5165\u53E3\u6587\u4EF6\u7F3A\u5931\uFF09`
+        );
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    throw new ResolveError(
+      `\u627E\u4E0D\u5230\u5305 "${specifier}"\uFF1A${dirname(fromFileAbs)} \u53CA\u5176\u5404\u7EA7\u7236\u76EE\u5F55\u4E0B\u90FD\u6CA1\u6709 node_modules/${name}\uFF08\u5148\u5728\u7EC8\u7AEF npm install ${name}\uFF09`
+    );
+  }
+  var RESOLVE_EXTENSIONS, ResolveError;
+  var init_node_resolve = __esm({
+    "src/node-resolve.ts"() {
+      "use strict";
+      init_path();
+      RESOLVE_EXTENSIONS = [".js", ".mjs", ".cjs", ".json"];
+      ResolveError = class extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "ResolveError";
+        }
+      };
+    }
+  });
+
+  // src/strip-types.ts
+  function isAnnotationLeader(token) {
+    return ANNOTATION_LEADERS.has(token) || TS_MODIFIERS.has(token);
+  }
+  function stripTypes(source) {
+    return new Eraser(source).run();
+  }
+  var UnsupportedTsSyntaxError, IDENT_START, IDENT_PART, DECL_KEYWORDS, TS_MODIFIERS, ANNOTATION_LEADERS, Eraser;
+  var init_strip_types = __esm({
+    "src/strip-types.ts"() {
+      "use strict";
+      UnsupportedTsSyntaxError = class extends Error {
+        constructor(construct, line) {
+          super(`\u4E0D\u53D7\u652F\u6301\u7684 TypeScript \u8BED\u6CD5\uFF1A${construct}\uFF08\u7B2C ${line} \u884C\uFF09\u2014\u2014\u6D4F\u89C8\u5668\u6D4B\u8BD5\u6C99\u7BB1\u53EA\u64E6\u9664\u7C7B\u578B\u6807\u6CE8`);
+          this.construct = construct;
+          this.line = line;
+          this.name = "UnsupportedTsSyntaxError";
+        }
+      };
+      IDENT_START = /[A-Za-z_$]/;
+      IDENT_PART = /[A-Za-z0-9_$]/;
+      DECL_KEYWORDS = /* @__PURE__ */ new Set(["const", "let", "var"]);
+      TS_MODIFIERS = /* @__PURE__ */ new Set([
+        "private",
+        "protected",
+        "public",
+        "readonly",
+        "abstract",
+        "override",
+        "declare"
+      ]);
+      ANNOTATION_LEADERS = /* @__PURE__ */ new Set(["(", ",", "{", ";", "erased", "modifier"]);
+      Eraser = class {
+        constructor(src) {
+          this.src = src;
+          this.chars = [...src];
+        }
+        chars;
+        tokens = [];
+        frames = [];
+        /** 刚消费 `class` 头：下一个 `{` 是类体起始。 */
+        pendingClassBody = false;
+        /** 刚消费 `=>`：其后的 `(` 是箭头函数参数列表（声明位）。 */
+        afterArrow = false;
+        /** 刚消费 `function` 关键字：其后的标识符是函数名，再后是参数列表。 */
+        afterFunctionKeyword = false;
+        /** 最近一次 `)` 闭合的是不是参数列表（返回值标注判据）。 */
+        justClosedDeclareParen = false;
+        i = 0;
+        run() {
+          while (this.i < this.src.length) {
+            if (/\s/.test(this.ch())) {
+              this.i++;
+              continue;
+            }
+            if (this.copyTrivia()) continue;
+            if (this.copyLiteral()) continue;
+            if (this.copyRegexIfNeeded()) continue;
+            if (this.readNumber()) continue;
+            const word = this.readWord();
+            if (word !== null) this.handleWord(word);
+            else this.handlePunctuation();
+          }
+          return this.chars.join("");
+        }
+        /* ———————————————————— 游标原语 ———————————————————— */
+        ch(offset = 0) {
+          return this.src[this.i + offset] ?? "";
+        }
+        /** 回看第 `back` 个显著 token（1 = 最近一个）。 */
+        tokenAt(back) {
+          return this.tokens[this.tokens.length - back] ?? "";
+        }
+        /** 擦除结果里 `from` 往前的最后一个非空白字符（看的是已擦除文本，不是原文）。 */
+        prevSignificantChar(from) {
+          for (let j = from; j >= 0; j--) {
+            const c = this.chars[j];
+            if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") return c;
+          }
+          return "";
+        }
+        /** 擦除 `[from, to)`：填等长空格，换行照抄——擦完行号与原文件一致。 */
+        erase(from, to) {
+          for (let j = Math.max(from, 0); j < to; j++) this.chars[j] = this.src[j] === "\n" ? "\n" : " ";
+        }
+        pushToken(token) {
+          this.afterArrow = token === "=>";
+          this.afterFunctionKeyword = token === "function";
+          this.tokens.push(token);
+        }
+        /** 数字面量整段消费（否则 `1.5` 会被拆成 `1` `.` `5`，`.` 参与判据时误判）。 */
+        readNumber() {
+          if (!/[0-9]/.test(this.ch())) return false;
+          let end = this.i;
+          while (end < this.src.length && /[0-9a-fA-FxXoObB._]/.test(this.src[end])) end++;
+          this.i = end;
+          this.pushToken("number");
+          return true;
+        }
+        readWord() {
+          if (!IDENT_START.test(this.ch())) return null;
+          let end = this.i;
+          while (end < this.src.length && IDENT_PART.test(this.src[end])) end++;
+          const word = this.src.slice(this.i, end);
+          this.i = end;
+          this.pushToken(word);
+          return word;
+        }
+        /* —————————————— 字面量与注释：整段跳过（内容永不参与判定） —————————————— */
+        copyTrivia() {
+          const head = this.ch();
+          const next = this.ch(1);
+          if (head === "/" && next === "/") {
+            while (this.i < this.src.length && this.ch() !== "\n") this.i++;
+            return true;
+          }
+          if (head === "/" && next === "*") {
+            const end = this.src.indexOf("*/", this.i + 2);
+            this.i = end === -1 ? this.src.length : end + 2;
+            return true;
+          }
+          return false;
+        }
+        copyLiteral() {
+          const head = this.ch();
+          if (head !== "'" && head !== '"' && head !== "`") return false;
+          this.i = head === "`" ? this.scanTemplate(this.i) : this.scanQuoted(this.i);
+          this.pushToken(head === "`" ? "template" : "string");
+          return true;
+        }
+        /** 引号串结束下标（未闭合则到行尾，把真实的语法错误留给求值期）。 */
+        scanQuoted(start) {
+          const quote = this.src[start];
+          let j = start + 1;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "\\") j += 2;
+            else if (c === quote) return j + 1;
+            else if (c === "\n") return j;
+            else j++;
+          }
+          return this.src.length;
+        }
+        /** 模板串结束下标（`${}` 内按大括号配平，内层字符串 / 模板一并识别）。 */
+        scanTemplate(start) {
+          let j = start + 1;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "\\") j += 2;
+            else if (c === "`") return j + 1;
+            else if (c === "$" && this.src[j + 1] === "{") j = this.scanInterpolation(j + 2);
+            else j++;
+          }
+          return this.src.length;
+        }
+        scanInterpolation(start) {
+          let depth = 1;
+          let j = start;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "\\") j += 2;
+            else if (c === "'" || c === '"') j = this.scanQuoted(j);
+            else if (c === "`") j = this.scanTemplate(j);
+            else if (c === "{") {
+              depth++;
+              j++;
+            } else if (c === "}") {
+              depth--;
+              j++;
+              if (depth === 0) return j;
+            } else j++;
+          }
+          return this.src.length;
+        }
+        /**
+         * 正则字面量：`/` 只在「运算符位」才是正则起始（前一个显著字符不是值结尾）。
+         * 判不准时按除号处理——除号后面不会有需要擦除的类型标注，最坏只是漏擦。
+         * 有了这条，`const url = /https:\/\//` 里的 `:` 与 `//` 才不会被人当语法（恒等用例之一）。
+         */
+        copyRegexIfNeeded() {
+          if (this.ch() !== "/") return false;
+          const prev = this.prevSignificantChar(this.i - 1);
+          const valueEnding = prev !== "" && (IDENT_PART.test(prev) || prev === ")" || prev === "]" || prev === "}" || prev === '"' || prev === "'" || prev === "`");
+          if (valueEnding) return false;
+          const end = this.scanRegex(this.i);
+          if (end === null) return false;
+          this.i = end;
+          this.pushToken("regex");
+          return true;
+        }
+        scanRegex(start) {
+          let j = start + 1;
+          let inClass = false;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "\\") {
+              j += 2;
+              continue;
+            }
+            if (c === "\n") return null;
+            if (c === "[") inClass = true;
+            else if (c === "]") inClass = false;
+            else if (c === "/" && !inClass) {
+              j++;
+              while (j < this.src.length && /[a-z]/i.test(this.src[j])) j++;
+              return j;
+            }
+            j++;
+          }
+          return null;
+        }
+        /* ———————————————— 关键字与声明结构 ———————————————— */
+        handleWord(word) {
+          const start = this.i - word.length;
+          if (this.tokenAt(2) === ".") {
+            this.consumeGenericsAfterName();
+            return;
+          }
+          switch (word) {
+            case "interface": {
+              const after = this.skipWhitespaceFrom(this.skipNameAndParams(start + word.length));
+              if (after === null || this.src[after] !== "{") return;
+              const end = this.scanBalanced(after, "{", "}");
+              this.erase(start, end);
+              this.i = end;
+              this.pushToken("erased");
+              return;
+            }
+            case "type": {
+              const after = this.skipWhitespaceFrom(this.skipNameAndParams(this.i));
+              if (after === null || this.src[after] !== "=") return;
+              const end = this.scanTypeExpression(after + 1, true);
+              this.erase(start, end);
+              this.i = end;
+              this.pushToken("erased");
+              return;
+            }
+            case "import":
+            case "export": {
+              if (!/^\s+type\b/.test(this.src.slice(this.i))) return;
+              const after = this.skipNameAndParams(this.i);
+              if (after === null) return;
+              const end = this.scanStatementEnd(after);
+              this.erase(start, end);
+              this.i = end;
+              this.pushToken("erased");
+              return;
+            }
+            case "enum":
+            case "namespace":
+              throw new UnsupportedTsSyntaxError(word, this.lineAt(start));
+            case "implements": {
+              let j = this.i;
+              while (j < this.src.length && this.src[j] !== "{" && this.src[j] !== ";") j++;
+              this.erase(start, j);
+              this.i = j;
+              this.pushToken("erased");
+              return;
+            }
+            case "class":
+              this.pendingClassBody = true;
+              return;
+            case "as":
+            case "satisfies": {
+              if (this.tokenAt(2) === "*" || this.tokenAt(2) === "type") return;
+              const nextChar = this.skipWhitespaceFrom(this.i);
+              if (nextChar === null || "=,:]})".includes(this.src[nextChar])) return;
+              const end = this.scanTypeExpression(this.i, false);
+              this.erase(start, end);
+              this.i = end;
+              return;
+            }
+            default: {
+              if (TS_MODIFIERS.has(word) && this.inClassBody()) {
+                const next = this.peekWord();
+                if (next === "" || /[{(=]/.test(next[0])) return;
+                this.erase(start, this.i);
+                this.pushToken("modifier");
+                return;
+              }
+              this.consumeGenericsAfterName();
+            }
+          }
+        }
+        peekWord() {
+          let j = this.i;
+          while (j < this.src.length && /\s/.test(this.src[j])) j++;
+          let end = j;
+          while (end < this.src.length && IDENT_PART.test(this.src[end])) end++;
+          return this.src.slice(j, end);
+        }
+        lineAt(index) {
+          let line = 1;
+          for (let j = 0; j < index; j++) if (this.src[j] === "\n") line++;
+          return line;
+        }
+        /** `:` 之前紧邻的是不是 `)`（返回值标注位；用于决定是否允许顶层 `=>` 续读）。 */
+        lastSignificantCharIsCloseParen(at) {
+          return this.prevSignificantChar(at - 1) === ")";
+        }
+        inClassBody() {
+          return this.frames[this.frames.length - 1]?.classBody === true;
+        }
+        /** 当前帧是不是声明位（参数列表 / 类体）——只有这里才允许把 `:` 判成标注。 */
+        inDeclarePosition() {
+          const frame = this.frames[this.frames.length - 1];
+          return frame !== void 0 && (frame.declare || frame.classBody);
+        }
+        /* ———————————————— 标点与括号帧 ———————————————— */
+        handlePunctuation() {
+          const c = this.ch();
+          const start = this.i;
+          if (c === "(" || c === "{" || c === "[") {
+            const frame = {
+              kind: c === "(" ? "paren" : c === "{" ? "brace" : "bracket",
+              declare: false,
+              classBody: false
+            };
+            if (c === "{" && this.pendingClassBody) {
+              frame.classBody = true;
+              this.pendingClassBody = false;
+            }
+            if (c === "(" && this.isDeclareParen(start)) frame.declare = true;
+            this.frames.push(frame);
+            this.i++;
+            this.pushToken(c);
+            return;
+          }
+          if (c === ")" || c === "}" || c === "]") {
+            const closed = this.frames.pop();
+            if (closed?.kind === "paren") this.justClosedDeclareParen = closed.declare;
+            this.i++;
+            this.pushToken(c);
+            return;
+          }
+          if (c === ":") {
+            if (this.ch(1) === ":") {
+              this.i++;
+              this.pushToken(":");
+              return;
+            }
+            const returnType = this.isAnnotationColon(start) && this.lastSignificantCharIsCloseParen(start);
+            if (returnType || this.isAnnotationColon(start)) {
+              const end = this.scanTypeExpression(start + 1, false, returnType);
+              this.erase(start, end);
+              this.i = end;
+              this.pushToken("erased");
+              return;
+            }
+            this.i++;
+            this.pushToken(":");
+            return;
+          }
+          if (c === "?" && this.ch(1) !== "?" && this.ch(1) !== ".") {
+            let j = start + 1;
+            while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
+            if (this.src[j] === ":" && this.inDeclarePosition() && IDENT_PART.test(this.prevSignificantChar(start - 1))) {
+              const end = this.scanTypeExpression(j + 1, false);
+              this.erase(start, end);
+              this.i = end;
+              this.pushToken("erased");
+              return;
+            }
+            this.i++;
+            this.pushToken("?");
+            return;
+          }
+          if (c === "!" && this.ch(1) !== "=" && this.isPostfixBang(start)) {
+            this.erase(start, start + 1);
+            this.i++;
+            return;
+          }
+          if (c === "=" && this.ch(1) === ">") {
+            this.i += 2;
+            this.pushToken("=>");
+            return;
+          }
+          if (c === "<" && this.consumeLeadingGenerics(start)) return;
+          this.i++;
+          this.pushToken(c);
+        }
+        /** 空白跳跃（供声明结构找下一个非空白字符；不改游标，纯函数）。 */
+        skipWhitespaceFrom(index) {
+          if (index === null) return null;
+          let j = index;
+          while (j < this.src.length && /\s/.test(this.src[j])) j++;
+          return j;
+        }
+        /**
+         * 运算符位上的泛型参数列表（`const f = <T, >(x: T) => x`、`arr.map<T2>(...)` 之外的箭头形态）：
+         * 前一个显著字符不是值结尾（否则是 `a < b` 比较），且 `>` 之后紧跟 `(` 才擦。
+         */
+        consumeLeadingGenerics(at) {
+          if (!"([{,=;:>!&|?".includes(this.prevSignificantChar(at - 1))) return false;
+          const end = this.scanTypeParams(at);
+          if (end === null) return false;
+          const after = this.skipWhitespaceFrom(end);
+          if (after === null || this.src[after] !== "(") return false;
+          this.erase(at, end);
+          this.i = end;
+          return true;
+        }
+        /**
+         * `(` 是否为参数列表（声明位）：`function f(`、类体里的方法 `m(`、箭头 `=> (`，
+         * 以及出现在 `(` `,` `=` `>` `:` `[` `{` `}` `;` 之后（如 `map((v: T) => v)` 的内层括号）。
+         * 调用位 `foo(` 与控制流 `if (` `for (` 都不算。
+         * 误判成声明位也不足以擦掉什么：`:` 还要过 `isAnnotationColon` 的「名字前驱必须是
+         * `(` `,` `{` `;` 修饰符」这一关，而三元表达式的中间段前面必然是 `?`。
+         */
+        isDeclareParen(at) {
+          if (this.afterFunctionKeyword) return true;
+          if (this.tokenAt(2) === "function" && IDENT_START.test(this.tokenAt(1))) return true;
+          if (this.afterArrow) return true;
+          if (this.inClassBody() && IDENT_PART.test(this.prevSignificantChar(at - 1))) return true;
+          const prev = this.prevSignificantChar(at - 1);
+          return prev === "" || "(,=>:[{};".includes(prev);
+        }
+        /** `:` 是类型标注吗：看名字前驱 token 与所在帧（对象键、三元、`case` 一律排除）。 */
+        isAnnotationColon(at) {
+          const prev = this.prevSignificantChar(at - 1);
+          if (prev === ")") return this.justClosedDeclareParen;
+          if (prev === "}" || prev === "]") {
+            const frame = this.frames[this.frames.length - 1];
+            return frame?.kind === "paren" && frame.declare;
+          }
+          if (!IDENT_PART.test(prev)) return false;
+          if (this.tokenAt(1) === "number" || this.tokenAt(1) === "string") return false;
+          if (this.inDeclarePosition() && isAnnotationLeader(this.tokenAt(2))) return true;
+          return DECL_KEYWORDS.has(this.tokenAt(2));
+        }
+        /** 非空断言 `x!`：前一个显著字符是值结尾，且后一个非空白字符不是操作数起始。 */
+        isPostfixBang(at) {
+          const prev = this.prevSignificantChar(at - 1);
+          if (!(IDENT_PART.test(prev) || prev === ")" || prev === "]")) return false;
+          let j = at + 1;
+          while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
+          const next = this.src[j] ?? "";
+          if (next === "") return true;
+          return !(IDENT_START.test(next) || /[0-9]/.test(next) || "(![~".includes(next));
+        }
+        /* ———————————————— 区间扫描（全部字符串 / 注释安全） ———————————————— */
+        /** 跳过「名字 + 泛型参数」；没有合法名字时返回 null（`{ type: 1 }` 因此落空）。 */
+        skipNameAndParams(from) {
+          let j = from;
+          while (j < this.src.length && /\s/.test(this.src[j])) j++;
+          const nameStart = j;
+          while (j < this.src.length && IDENT_PART.test(this.src[j])) j++;
+          if (j === nameStart) return null;
+          const generic = this.scanTypeParams(j);
+          return generic === null ? j : generic;
+        }
+        /** `<T, U extends X>`：返回 `>` 之后的下标；跨到 `)` `]` `;` 换行前配不平则 null。 */
+        scanTypeParams(from) {
+          if (this.src[from] !== "<") return null;
+          let depth = 0;
+          let j = from;
+          for (; j < this.src.length; j++) {
+            const c = this.src[j];
+            if (c === "<") depth++;
+            else if (c === ">") {
+              depth--;
+              if (depth === 0) return j + 1;
+            } else if (c === ")" || c === "]" || c === ";" || c === "\n") return null;
+            else if (c === "'" || c === '"') j = this.scanQuoted(j) - 1;
+            else if (c === "`") j = this.scanTemplate(j) - 1;
+          }
+          return null;
+        }
+        /**
+         * 消费「刚读出的标识符之后」的泛型实参 / 类型参数（`function f<T>(`、方法 `m<T>(`、`f<T>(x)`）。
+         * 只有 `>` 之后紧跟 `(` / `{` / `implements` 才算——`if (a < b) {` 里 `>` 之后是 `)`，故安全。
+         */
+        consumeGenericsAfterName() {
+          if (this.ch() !== "<") return;
+          const end = this.scanTypeParams(this.i);
+          if (end === null) return;
+          let j = end;
+          while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
+          const after = this.src.slice(j);
+          if (!/^[({]/.test(after) && !/^implements\b/.test(after)) return;
+          this.erase(this.i, end);
+          this.i = end;
+        }
+        /** 括号配平：返回闭括号之后的下标（未配平则到文件尾）。 */
+        scanBalanced(from, open, close) {
+          let depth = 0;
+          let j = from;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "'" || c === '"') j = this.scanQuoted(j);
+            else if (c === "`") j = this.scanTemplate(j);
+            else if (c === "/" && (this.src[j + 1] === "/" || this.src[j + 1] === "*"))
+              j = this.skipComment(j);
+            else if (c === open) {
+              depth++;
+              j++;
+            } else if (c === close) {
+              depth--;
+              j++;
+              if (depth === 0) return j;
+            } else j++;
+          }
+          return this.src.length;
+        }
+        skipComment(from) {
+          if (this.src[from + 1] === "/") {
+            const end2 = this.src.indexOf("\n", from);
+            return end2 === -1 ? this.src.length : end2;
+          }
+          const end = this.src.indexOf("*/", from + 2);
+          return end === -1 ? this.src.length : end + 2;
+        }
+        /** 语句结束（`;` 或括号已配平时的行尾），用于 `import type …`。 */
+        scanStatementEnd(from) {
+          let depth = 0;
+          let j = from;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "'" || c === '"') j = this.scanQuoted(j);
+            else if (c === "`") j = this.scanTemplate(j);
+            else if (c === "{" || c === "(" || c === "[") {
+              depth++;
+              j++;
+            } else if (c === "}" || c === ")" || c === "]") {
+              depth--;
+              j++;
+            } else if (c === ";" || c === "\n" && depth <= 0) break;
+            else j++;
+          }
+          return j;
+        }
+        /**
+         * 类型表达式结束下标：消费标识符 / 字符串字面量类型 / 泛型实参 / 元组 / 对象类型 /
+         * 函数类型（含 `=>` 返回值）/ 联合与交叉；在深度 0 的 `= , ; ) ]` 与「已结束的行」处停下。
+         *
+         * 两处歧义的处理：
+         * - `function f(): { a: number } { … }`——还没消费过类型原子时遇到的 `{` 属于类型，
+         *   之后再遇 `{` 才是函数体；`type X = A` 的初始值花括号整体算类型（`leadingBraceIsType`）。
+         * - `const x: Foo = { … }`——在 `=` 处停，不会把右侧对象字面量吞掉。
+         */
+        scanTypeExpression(from, leadingBraceIsType, topLevelArrowEnds = false) {
+          let depth = 0;
+          let j = from;
+          let sawAtom = false;
+          while (j < this.src.length) {
+            const c = this.src[j];
+            if (c === "'" || c === '"') {
+              j = this.scanQuoted(j);
+              sawAtom = true;
+            } else if (c === "`") {
+              j = this.scanTemplate(j);
+              sawAtom = true;
+            } else if (c === "/" && (this.src[j + 1] === "/" || this.src[j + 1] === "*")) {
+              j = this.skipComment(j);
+            } else if (c === "(" || c === "[") {
+              depth++;
+              sawAtom = true;
+              j++;
+            } else if (c === ")" || c === "]") {
+              if (depth === 0) break;
+              depth--;
+              j++;
+            } else if (c === "{") {
+              if (depth === 0 && sawAtom && !leadingBraceIsType) break;
+              j = this.scanBalanced(j, "{", "}");
+              sawAtom = true;
+            } else if (c === "}") {
+              if (depth === 0) break;
+              depth--;
+              j++;
+            } else if (depth === 0 && (c === "," || c === ";")) break;
+            else if (depth === 0 && c === "=") {
+              if (this.src[j + 1] === ">" && !topLevelArrowEnds) {
+                j += 2;
+                continue;
+              }
+              break;
+            } else if (depth === 0 && c === "\n") {
+              if (!this.typeContinuesAt(j)) break;
+              j++;
+            } else if (c === "<") {
+              const generic = this.scanTypeParams(j);
+              if (generic === null) break;
+              j = generic;
+              sawAtom = true;
+            } else {
+              if (IDENT_PART.test(c)) sawAtom = true;
+              j++;
+            }
+          }
+          return j;
+        }
+        /**
+         * 行尾处类型是否仍在继续：`type Id = string\n  | number` 要接得上，
+         * 而 `const x: Foo\nconst y = 1` 必须停。判据是两侧的非空邻字——
+         * 前一个是连接符（`| & < > = , . ? : (`）或后一个是连接符 / 闭合符（`| & , . ? : ) ] } >`）。
+         */
+        typeContinuesAt(index) {
+          for (let j = index - 1; j >= 0; j--) {
+            const c = this.src[j];
+            if (/\s/.test(c)) continue;
+            if ("|&<>=,.?:(".includes(c)) return true;
+            break;
+          }
+          for (let j = index + 1; j < this.src.length; j++) {
+            const c = this.src[j];
+            if (/\s/.test(c)) continue;
+            return "|&,.?:)]}>".includes(c);
+          }
+          return false;
+        }
+      };
+    }
+  });
+
+  // src/preview-server.ts
+  var preview_server_exports = {};
+  __export(preview_server_exports, {
     buildPreviewDocument: () => buildPreviewDocument,
     createPreviewServer: () => createPreviewServer,
     inlineAssets: () => inlineAssets
@@ -190,20 +977,664 @@ var AdepWebContainer = (() => {
     };
   }
   var EXTERNAL_SRC;
-  var init_preview = __esm({
-    "src/preview.ts"() {
+  var init_preview_server = __esm({
+    "src/preview-server.ts"() {
       "use strict";
       init_path();
       EXTERNAL_SRC = /(?:^https?:)?\/\//i;
     }
   });
 
+  // src/function-fetch-proxy.ts
+  function parseBodyByContentType(rawBody, headers) {
+    if (rawBody === null) return void 0;
+    const contentType = headers["content-type"] ?? headers["Content-Type"] ?? headers["CONTENT-TYPE"] ?? "";
+    if (!/json/i.test(contentType)) return rawBody;
+    try {
+      return JSON.parse(rawBody);
+    } catch {
+      return rawBody;
+    }
+  }
+  function createFunctionFetchHandler(options) {
+    return async (event) => {
+      const data = event.data;
+      if (!data || data.__adepFnRequest !== true) return;
+      const source = event.source;
+      const post = source?.postMessage;
+      if (typeof post !== "function") return;
+      const reply = (payload) => {
+        try {
+          post.call(source, { __adepFnResponse: true, ...payload }, "*");
+        } catch {
+        }
+      };
+      try {
+        const id = data.id;
+        const method = String(data.method ?? "GET").toUpperCase();
+        const url = String(data.url ?? "");
+        const headers = typeof data.headers === "object" && data.headers !== null ? data.headers : {};
+        const rawBody = typeof data.body === "string" ? data.body : data.body === null || data.body === void 0 ? null : String(data.body);
+        const qIndex = url.indexOf("?");
+        const pathPart = qIndex === -1 ? url : url.slice(0, qIndex);
+        const queryPart = qIndex === -1 ? "" : url.slice(qIndex + 1);
+        const match = pathPart.match(/^\/api\/([^/]+)(\/.*)?$/);
+        if (match === null) {
+          reply({
+            id,
+            status: 404,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              error: { code: "FN_NOT_FOUND", message: `\u65E0\u6CD5\u89E3\u6790\u7684\u4E91\u51FD\u6570\u8DEF\u5F84: ${url}` }
+            })
+          });
+          return;
+        }
+        const fnName = decodeURIComponent(match[1] ?? "");
+        const subPath = match[2] ?? "/";
+        const query = {};
+        if (queryPart !== "") {
+          try {
+            new URLSearchParams(queryPart).forEach((value, key) => {
+              query[key] = value;
+            });
+          } catch {
+          }
+        }
+        const files = await options.getFunctionFiles(fnName);
+        if (files === null || Object.keys(files).length === 0) {
+          reply({
+            id,
+            status: 404,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              error: {
+                code: "FN_NOT_FOUND",
+                message: `\u4E91\u51FD\u6570 "${fnName}" \u4E0D\u5B58\u5728\u6216\u5C1A\u672A\u52A0\u8F7D\u8349\u7A3F`
+              }
+            })
+          });
+          return;
+        }
+        const entry = files["index.ts"] !== void 0 ? "index.ts" : Object.keys(files)[0] ?? "";
+        if (entry === "") {
+          reply({
+            id,
+            status: 500,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              error: { code: "FN_NO_ENTRY", message: `\u4E91\u51FD\u6570 "${fnName}" \u6CA1\u6709\u53EF\u6267\u884C\u6587\u4EF6` }
+            })
+          });
+          return;
+        }
+        const body = parseBodyByContentType(rawBody, headers);
+        const result = await options.runner.run({
+          files,
+          entry,
+          request: {
+            method,
+            path: subPath,
+            query,
+            headers,
+            ...body === void 0 ? {} : { body }
+          },
+          bundle: options.bundle
+        });
+        let status = result.status;
+        let outBody;
+        let outContentType = "application/json";
+        if (result.error !== void 0) {
+          if (status === 200) status = 500;
+          outBody = JSON.stringify({ error: result.error });
+        } else if (typeof result.body === "string") {
+          outBody = result.body;
+          outContentType = "text/plain; charset=utf-8";
+        } else {
+          outBody = JSON.stringify(result.body ?? null);
+        }
+        reply({ id, status, headers: { "content-type": outContentType }, body: outBody });
+      } catch (error) {
+        reply({
+          id: data?.id,
+          status: 500,
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            error: {
+              code: "FN_PROXY_ERROR",
+              message: error instanceof Error ? error.message : String(error)
+            }
+          })
+        });
+      }
+    };
+  }
+  var FN_FETCH_INTERCEPTOR_SCRIPT;
+  var init_function_fetch_proxy = __esm({
+    "src/function-fetch-proxy.ts"() {
+      "use strict";
+      FN_FETCH_INTERCEPTOR_SCRIPT = (function() {
+        var src = [
+          "(function () {",
+          "  if (window.__adepFnProxyInstalled) return;",
+          "  window.__adepFnProxyInstalled = true;",
+          "  var ORIGINAL_FETCH = window.fetch.bind(window);",
+          "  var pending = {};",
+          "  var nextId = 1;",
+          "  var TIMEOUT_MS = 15000;",
+          "",
+          '  window.addEventListener("message", function (event) {',
+          "    var data = event.data;",
+          "    if (!data || data.__adepFnResponse !== true) return;",
+          "    var entry = pending[data.id];",
+          "    if (!entry) return;",
+          "    delete pending[data.id];",
+          "    clearTimeout(entry.timer);",
+          "    var headers;",
+          "    try { headers = new Headers(data.headers || {}); }",
+          '    catch (e) { headers = new Headers({ "content-type": "text/plain" }); }',
+          "    var body = data.body == null ? null : data.body;",
+          "    try {",
+          '      entry.resolve(new Response(body, { status: data.status || 200, statusText: "", headers: headers }));',
+          "    } catch (e2) {",
+          '      entry.resolve(new Response(String(body), { status: data.status || 200, headers: { "content-type": "text/plain" } }));',
+          "    }",
+          "  });",
+          "",
+          "  function readBody(input, init) {",
+          '    if (typeof Request !== "undefined" && input instanceof Request) {',
+          "      return input.text().catch(function () { return null; });",
+          "    }",
+          "    var body = init && init.body !== undefined ? init.body : input;",
+          "    if (body == null) return Promise.resolve(null);",
+          '    if (typeof body === "string") return Promise.resolve(body);',
+          '    if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {',
+          "      return Promise.resolve(new TextDecoder().decode(body));",
+          "    }",
+          '    if (typeof Blob !== "undefined" && body instanceof Blob) return body.text();',
+          '    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {',
+          "      return Promise.resolve(body.toString());",
+          "    }",
+          "    try { return Promise.resolve(String(body)); } catch (e) { return Promise.resolve(null); }",
+          "  }",
+          "",
+          "  function collectHeaders(input, init) {",
+          "    var out = {};",
+          "    try { input.headers.forEach(function (v, k) { out[k] = v; }); } catch (e) {}",
+          "    if (init && init.headers) {",
+          "      try { new Headers(init.headers).forEach(function (v, k) { out[k] = v; }); } catch (e2) {}",
+          "    }",
+          "    return out;",
+          "  }",
+          "",
+          "  window.fetch = function (input, init) {",
+          "    var urlStr;",
+          "    var method;",
+          "    var headers = {};",
+          '    var isRequest = typeof Request !== "undefined" && input instanceof Request;',
+          "    if (isRequest) {",
+          "      urlStr = String(input.url);",
+          '      method = (init && init.method) || input.method || "GET";',
+          "      headers = collectHeaders(input, init);",
+          '    } else if (typeof input === "string" || (typeof URL !== "undefined" && input instanceof URL)) {',
+          "      urlStr = String(input);",
+          '      method = (init && init.method) || "GET";',
+          "      try { new Headers(init && init.headers || {}).forEach(function (v, k) { headers[k] = v; }); } catch (e) {}",
+          "    } else {",
+          "      return ORIGINAL_FETCH(input, init);",
+          "    }",
+          "    var u;",
+          "    try { u = new URL(urlStr, document.baseURI); }",
+          "    catch (e) { return ORIGINAL_FETCH(input, init); }",
+          '    if (u.pathname.indexOf("/api/") !== 0 && u.pathname !== "/api") {',
+          "      return ORIGINAL_FETCH(input, init);",
+          "    }",
+          "    if (window.parent === window) return ORIGINAL_FETCH(input, init);",
+          '    method = (method || "GET").toUpperCase();',
+          "    var target = u.pathname + u.search;",
+          "    return readBody(input, init).then(function (textBody) {",
+          "      return new Promise(function (resolve) {",
+          "        var id = nextId++;",
+          "        var timer = setTimeout(function () {",
+          "          delete pending[id];",
+          `          resolve(new Response('{"error":{"code":"FN_PROXY_TIMEOUT","message":"\\u4e91\\u51fd\\u6570\\u6267\\u884c\\u8d85\\u65f6"}}', { status: 504, headers: { "content-type": "application/json" } }));`,
+          "        }, TIMEOUT_MS);",
+          "        pending[id] = { resolve: resolve, timer: timer };",
+          '        window.parent.postMessage({ __adepFnRequest: true, id: id, method: method, url: target, headers: headers, body: textBody }, "*");',
+          "      });",
+          "    });",
+          "  };",
+          "})();"
+        ].join("\n");
+        return src;
+      })();
+    }
+  });
+
+  // src/vite-dev.ts
+  var vite_dev_exports = {};
+  __export(vite_dev_exports, {
+    ViteDevError: () => ViteDevError,
+    createViteServer: () => createViteServer,
+    scanEsmSpecifiers: () => scanEsmSpecifiers
+  });
+  function tokenize2(source) {
+    const tokens = [];
+    let i = 0;
+    const n = source.length;
+    while (i < n) {
+      const ch = source[i];
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+        i++;
+        continue;
+      }
+      if (ch === "/" && source[i + 1] === "/") {
+        i = source.indexOf("\n", i);
+        if (i === -1) break;
+        continue;
+      }
+      if (ch === "/" && source[i + 1] === "*") {
+        const close = source.indexOf("*/", i + 2);
+        if (close === -1) break;
+        i = close + 2;
+        continue;
+      }
+      if (ch === "'" || ch === '"') {
+        let j = i + 1;
+        while (j < n && source[j] !== ch) {
+          if (source[j] === "\\") j++;
+          j++;
+        }
+        tokens.push({ kind: "string", text: source.slice(i, j + 1), start: i, end: j + 1 });
+        i = j + 1;
+        continue;
+      }
+      if (ch === "`") {
+        let j = i + 1;
+        while (j < n && source[j] !== "`") {
+          if (source[j] === "\\") j++;
+          j++;
+        }
+        tokens.push({ kind: "template", text: source.slice(i, j + 1), start: i, end: j + 1 });
+        i = j + 1;
+        continue;
+      }
+      if (ch === "/") {
+        const prev = tokens[tokens.length - 1];
+        const isRegex = prev === void 0 || prev.kind === "punct" && REGEX_PRECEDING_CHARS.has(prev.text) || prev.kind === "ident" && REGEX_PRECEDING_KEYWORDS.has(prev.text);
+        if (isRegex) {
+          let j = i + 1;
+          let inClass = false;
+          while (j < n) {
+            const c = source[j];
+            if (c === "\\") j++;
+            else if (c === "[") inClass = true;
+            else if (c === "]") inClass = false;
+            else if (c === "/" && !inClass) break;
+            else if (c === "\n") break;
+            j++;
+          }
+          tokens.push({ kind: "punct", text: "/", start: i, end: i + 1 });
+          i = j + 1;
+          continue;
+        }
+      }
+      if (isIdentStart(ch)) {
+        let j = i + 1;
+        while (j < n && isIdentPart(source[j])) j++;
+        tokens.push({ kind: "ident", text: source.slice(i, j), start: i, end: j });
+        i = j;
+        continue;
+      }
+      tokens.push({ kind: "punct", text: ch, start: i, end: i + 1 });
+      i++;
+    }
+    return tokens;
+  }
+  function scanEsmSpecifiers(source) {
+    const tokens = tokenize2(source);
+    const hits = [];
+    for (let i = 1; i < tokens.length; i++) {
+      const tok = tokens[i];
+      if (tok.kind !== "string") continue;
+      const prev = tokens[i - 1];
+      const prev2 = tokens[i - 2];
+      if (prev.kind !== "ident" && prev.kind !== "punct") continue;
+      if (prev.kind === "ident" && prev.text === "import") {
+        hits.push({ specifier: tok.text.slice(1, -1), start: tok.start, end: tok.end });
+        continue;
+      }
+      if (prev.kind === "ident" && prev.text === "from" && !(prev2?.kind === "punct" && ["=", ":", ",", "(", "["].includes(prev2.text))) {
+        hits.push({ specifier: tok.text.slice(1, -1), start: tok.start, end: tok.end });
+        continue;
+      }
+      if (prev.kind === "punct" && prev.text === "(" && prev2?.kind === "ident" && prev2.text === "import") {
+        hits.push({ specifier: tok.text.slice(1, -1), start: tok.start, end: tok.end });
+      }
+    }
+    return hits;
+  }
+  function cssModule(css) {
+    return [
+      `const css = ${JSON.stringify(css)};`,
+      'const el = document.createElement("style");',
+      'el.setAttribute("data-adep-vite", "");',
+      "el.textContent = css;",
+      "document.head.appendChild(el);",
+      "export default css;"
+    ].join("\n");
+  }
+  function jsonModule(source, abs) {
+    try {
+      JSON.parse(source);
+    } catch {
+      throw new ViteDevError("JSON_PARSE", `${abs} \u4E0D\u662F\u5408\u6CD5 JSON`);
+    }
+    return `export default ${source.trim()};`;
+  }
+  function resolveWithSuffixes(vfs, base) {
+    if (vfs.exists(base) && !vfs.isDirectory(base)) return base;
+    const asFile2 = VITE_RESOLVE_SUFFIXES.map((suffix) => `${base}${suffix}`);
+    const asIndex = VITE_RESOLVE_SUFFIXES.map((suffix) => join(base, `index${suffix}`));
+    return asFile2.find((p) => vfs.exists(p) && !vfs.isDirectory(p)) ?? asIndex.find((p) => vfs.exists(p) && !vfs.isDirectory(p)) ?? base;
+  }
+  function hmrScript(name) {
+    return `<script>(function(){if(typeof BroadcastChannel==='undefined')return;var bc=new BroadcastChannel(${JSON.stringify(
+      name
+    )});bc.onmessage=function(e){var d=e.data;if(d&&d.type==='update'&&d.url&&d.url!==location.href){location.replace(d.url);}};})();<\/script>`;
+  }
+  function createViteServer(vfs, options = {}) {
+    const root = normalize(options.root ?? "/");
+    const entry = options.entry ?? "index.html";
+    const sfcCompiler = options.sfcCompiler;
+    const createObjectURL = options.createObjectURL ?? ((blob) => URL.createObjectURL(blob));
+    const revokeObjectURL = options.revokeObjectURL ?? ((url) => URL.revokeObjectURL(url));
+    const channelName = `adep:vite:${Math.random().toString(36).slice(2)}`;
+    const port = 5173;
+    let moduleUrls = /* @__PURE__ */ new Map();
+    const inFlight = /* @__PURE__ */ new Set();
+    const stableUrls = /* @__PURE__ */ new Map();
+    let inlineSources = /* @__PURE__ */ new Map();
+    let currentUrl = "";
+    let lastDoc = null;
+    let bc = null;
+    let touchTimer = null;
+    let inlineSeq = 0;
+    const scheduleRebuild = () => {
+      if (touchTimer !== null) clearTimeout(touchTimer);
+      touchTimer = setTimeout(() => {
+        touchTimer = null;
+        void rebuild();
+      }, 100);
+    };
+    const broadcast = (url) => {
+      try {
+        bc ??= new BroadcastChannel(channelName);
+        bc.postMessage({ type: "update", url });
+      } catch {
+      }
+    };
+    function transformModule2(abs, source) {
+      if (abs.endsWith(".css")) return cssModule(source);
+      if (abs.endsWith(".json")) return jsonModule(source, abs);
+      if (abs.endsWith(".vue")) {
+        if (sfcCompiler === void 0)
+          throw new ViteDevError(
+            "SFC_NO_COMPILER",
+            `${abs} \u662F Vue SFC\uFF0C\u4F46\u5F53\u524D\u73AF\u5883\u672A\u88C5\u914D SFC \u7F16\u8BD1\u5668\uFF08IDE \u4FA7\u9700\u6CE8\u5165 vue/compiler-sfc\uFF09`
+          );
+        const compiled = sfcCompiler(source, abs);
+        return [...compiled.styles.map((css) => cssModule(css)), compiled.script].join("\n");
+      }
+      if (abs.endsWith(".tsx") || abs.endsWith(".jsx"))
+        throw new ViteDevError(
+          "JSX_UNSUPPORTED",
+          `${abs} \u4F7F\u7528 JSX\uFF1A\u6D4F\u89C8\u5668\u5185 vite \u53EA\u64E6\u9664 TS \u7C7B\u578B\u6807\u6CE8\uFF0C\u4E0D\u8F6C\u8BD1 JSX\uFF08\u8BF7\u7528 h() \u6E32\u67D3\u51FD\u6570\u6216 .vue SFC\uFF09`
+        );
+      if (abs.endsWith(".ts") || abs.endsWith(".mts")) return stripTypes(source);
+      return source;
+    }
+    async function resolveSpecifier(spec, importerAbs) {
+      if (EXTERNAL_SPECIFIER.test(spec) || DATA_OR_BLOB.test(spec)) return spec;
+      let target;
+      if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
+        const base = spec.startsWith("/") ? spec : join(dirname(importerAbs), spec);
+        target = resolveWithSuffixes(vfs, base);
+        if (!vfs.exists(target) || vfs.isDirectory(target))
+          throw new ViteDevError(
+            "RESOLVE",
+            `\u627E\u4E0D\u5230\u6A21\u5757 "${spec}"\uFF08\u81EA ${importerAbs}\uFF1B\u8BD5\u8FC7\u6269\u5C55\u540D ${VITE_RESOLVE_SUFFIXES.join("/")} \u4E0E\u76EE\u5F55 index\uFF09`
+          );
+      } else {
+        try {
+          target = resolveImport(vfs, spec, importerAbs, "import");
+        } catch (error) {
+          if (error instanceof ResolveError)
+            throw new ViteDevError(
+              "RESOLVE",
+              `${error.message}
+  \uFF08\u5728 ${importerAbs} \u4E2D import "${spec}"\uFF09`
+            );
+          throw error;
+        }
+      }
+      return loadModuleUrl(target);
+    }
+    async function loadModuleUrl(abs) {
+      const cached = moduleUrls.get(abs);
+      if (cached !== void 0) return cached;
+      if (inFlight.has(abs))
+        throw new ViteDevError(
+          "CYCLE",
+          `\u5FAA\u73AF\u4F9D\u8D56\uFF1A${[...inFlight, abs].join(" \u2192 ")}\uFF08blob \u6A21\u5757\u94FE\u7684\u6539\u5199\u53D1\u751F\u5728\u52A0\u8F7D\u671F\uFF0C\u73AF\u65E0\u6CD5\u6210\u94FE\uFF1B\u8BF7\u62C6\u6389\u73AF\u6216\u6539\u7528\u52A8\u6001 import()\uFF09`
+        );
+      inFlight.add(abs);
+      const pending = (async () => {
+        const source = inlineSources.get(abs) ?? vfs.readFile(abs);
+        const code = transformModule2(abs, source);
+        const hits = scanEsmSpecifiers(code);
+        const targets = await Promise.all(hits.map((hit) => resolveSpecifier(hit.specifier, abs)));
+        let out = code;
+        for (let i = hits.length - 1; i >= 0; i--) {
+          const hit = hits[i];
+          out = out.slice(0, hit.start) + JSON.stringify(targets[i]) + out.slice(hit.end);
+        }
+        const key = `${abs}\0${out}`;
+        let url = stableUrls.get(key);
+        if (url === void 0) {
+          url = createObjectURL(new Blob([out], { type: "text/javascript" }));
+          stableUrls.set(key, url);
+        }
+        return url;
+      })();
+      moduleUrls.set(abs, pending);
+      try {
+        return await pending;
+      } catch (error) {
+        moduleUrls.delete(abs);
+        throw error;
+      } finally {
+        inFlight.delete(abs);
+      }
+    }
+    const revokeStableUrls = () => {
+      for (const url of stableUrls.values()) revokeObjectURL(url);
+      stableUrls.clear();
+    };
+    function directoryListing2() {
+      const rows = vfs.listDirectory(root).map((e) => `<li>${e.type === "file" ? "\u{1F4C4}" : "\u{1F4C1}"} <code>${e.path}</code></li>`).join("");
+      return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><title>vite \xB7 ${root}</title></head>
+<body style="font-family:system-ui;padding:24px"><h3>vite dev server \xB7 <code>${root}</code></h3>
+<p>\u672A\u627E\u5230\u5165\u53E3 <code>${entry}</code>\u3002\u5F53\u524D\u76EE\u5F55\u5185\u5BB9\uFF1A</p><ul>${rows}</ul>
+<p style="color:#64748b">\u5728 root \u4E0B\u521B\u5EFA ${entry}\uFF0C\u7528 &lt;script type="module" src="./main.ts"&gt; \u5F15\u5165\u6A21\u5757\u5165\u53E3\u3002</p></body></html>`;
+    }
+    function errorDocument(error) {
+      const reason = error instanceof ViteDevError ? error.reason : "BUILD_FAILED";
+      const message = error instanceof Error ? error.message : String(error);
+      return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><title>vite error</title></head>
+<body style="font-family:ui-monospace,monospace;background:#1a1c24;color:#e2e8f0;padding:24px">
+<h2 style="color:#f43f5e;margin-top:0">[vite] ${reason}</h2>
+<pre style="white-space:pre-wrap;word-break:break-all;line-height:1.7">${message.replace(/&/g, "&amp;").replace(/</g, "&lt;")}</pre>
+<p style="color:#94a3b8">\u4FEE\u590D\u4EE3\u7801\u540E\u9884\u89C8\u81EA\u52A8\u91CD\u5EFA\uFF1B\u4E5F\u53EF\u5728\u7EC8\u7AEF\u6267\u884C vite stop / vite &lt;dir&gt; \u91CD\u542F\u3002</p>
+</body></html>`;
+    }
+    async function buildDocument() {
+      const entryAbs = join(root, entry);
+      if (!vfs.exists(entryAbs) || vfs.isDirectory(entryAbs)) return directoryListing2();
+      let html = vfs.readFile(entryAbs);
+      html = inlineAssets(html, vfs, dirname(entryAbs));
+      const entryModuleUrls = [];
+      html = html.replace(
+        MODULE_SCRIPT_SRC_RE,
+        (_whole, pre, _q1, mid, _q2, src, post) => {
+          const base = src.startsWith("/") ? normalize(src) : join(dirname(entryAbs), src);
+          const abs = resolveWithSuffixes(vfs, base);
+          if (!vfs.exists(abs) || vfs.isDirectory(abs))
+            throw new ViteDevError(
+              "RESOLVE",
+              `\u5165\u53E3 module script \u627E\u4E0D\u5230 "${src}"\uFF08root: ${root}\uFF1B\u8BD5\u8FC7\u6269\u5C55\u540D ${VITE_RESOLVE_SUFFIXES.join("/")} \u4E0E\u76EE\u5F55 index\uFF09`
+            );
+          entryModuleUrls.push(loadModuleUrl(abs));
+          return `<script${pre}${mid}src="__adep_vite_entry_${entryModuleUrls.length - 1}__"${post}><\/script>`;
+        }
+      );
+      html = html.replace(
+        MODULE_SCRIPT_INLINE_RE,
+        (whole, pre, _q, post, body) => {
+          if (/\bsrc\s*=/.test(pre + post)) return whole;
+          const abs = `${INLINE_PREFIX}${inlineSeq++}.mjs`;
+          inlineSources.set(abs, body);
+          entryModuleUrls.push(loadModuleUrl(abs));
+          return `<script${pre}${post}src="__adep_vite_entry_${entryModuleUrls.length - 1}__"><\/script>`;
+        }
+      );
+      const urls = await Promise.all(entryModuleUrls);
+      html = html.replace(/__adep_vite_entry_(\d+)__/g, (_m, idx) => urls[Number(idx)] ?? "");
+      const interceptor = `<script>${FN_FETCH_INTERCEPTOR_SCRIPT}<\/script>`;
+      html = /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (m) => `${m}${interceptor}`) : `${interceptor}${html}`;
+      const hmr = hmrScript(channelName);
+      return /<\/body>/i.test(html) ? html.replace(/<\/(body)>/i, `${hmr}</$1>`) : html + hmr;
+    }
+    async function rebuild() {
+      moduleUrls = /* @__PURE__ */ new Map();
+      inlineSources = /* @__PURE__ */ new Map();
+      inlineSeq = 0;
+      let doc;
+      try {
+        doc = await buildDocument();
+      } catch (error) {
+        doc = errorDocument(error);
+      }
+      const changed = lastDoc !== null && doc !== lastDoc;
+      lastDoc = doc;
+      if (currentUrl !== "") revokeObjectURL(currentUrl);
+      currentUrl = createObjectURL(new Blob([doc], { type: "text/html" }));
+      if (changed) broadcast(currentUrl);
+    }
+    const server = {
+      get url() {
+        return currentUrl;
+      },
+      get port() {
+        return port;
+      },
+      get root() {
+        return root;
+      },
+      ready: rebuild(),
+      touch() {
+        scheduleRebuild();
+      },
+      async stop() {
+        if (touchTimer !== null) {
+          clearTimeout(touchTimer);
+          touchTimer = null;
+        }
+        unsubscribeMutate();
+        moduleUrls = /* @__PURE__ */ new Map();
+        revokeStableUrls();
+        if (currentUrl !== "") revokeObjectURL(currentUrl);
+        currentUrl = "";
+        bc?.close();
+        bc = null;
+      }
+    };
+    const unsubscribeMutate = vfs.onMutate(scheduleRebuild);
+    return server;
+  }
+  var ViteDevError, REGEX_PRECEDING_CHARS, REGEX_PRECEDING_KEYWORDS, isIdentStart, isIdentPart, VITE_RESOLVE_SUFFIXES, INLINE_PREFIX, EXTERNAL_SPECIFIER, DATA_OR_BLOB, MODULE_SCRIPT_SRC_RE, MODULE_SCRIPT_INLINE_RE;
+  var init_vite_dev = __esm({
+    "src/vite-dev.ts"() {
+      "use strict";
+      init_path();
+      init_node_resolve();
+      init_strip_types();
+      init_preview_server();
+      init_function_fetch_proxy();
+      ViteDevError = class extends Error {
+        constructor(reason, message) {
+          super(message);
+          this.reason = reason;
+          this.name = "ViteDevError";
+        }
+      };
+      REGEX_PRECEDING_CHARS = /* @__PURE__ */ new Set([
+        "=",
+        "(",
+        ",",
+        "[",
+        "!",
+        "&",
+        "|",
+        "?",
+        ":",
+        ";",
+        "{",
+        "}",
+        "^",
+        "~",
+        "<",
+        ">",
+        "+",
+        "-",
+        "*",
+        "/",
+        "%"
+      ]);
+      REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+        "return",
+        "typeof",
+        "instanceof",
+        "in",
+        "of",
+        "new",
+        "delete",
+        "void",
+        "throw",
+        "case",
+        "do",
+        "else",
+        "yield",
+        "await"
+      ]);
+      isIdentStart = (ch) => /[A-Za-z_$]/.test(ch);
+      isIdentPart = (ch) => /[A-Za-z0-9_$]/.test(ch);
+      VITE_RESOLVE_SUFFIXES = [".ts", ".js", ".mjs", ".mts", ".vue", ".json", ".css"];
+      INLINE_PREFIX = "/__vite_inline_";
+      EXTERNAL_SPECIFIER = /^(?:https?:)?\/\//i;
+      DATA_OR_BLOB = /^(?:data|blob):/i;
+      MODULE_SCRIPT_SRC_RE = /<script\b([^>]*?)\btype\s*=\s*(["'])module\2([^>]*?)\bsrc\s*=\s*(["'])(.*?)\4([^>]*)><\/script>/gi;
+      MODULE_SCRIPT_INLINE_RE = /<script\b([^>]*?)\btype\s*=\s*(["'])module\2([^>]*)>([\s\S]*?)<\/script>/gi;
+    }
+  });
+
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
     COMPLETABLE_COMMANDS: () => COMPLETABLE_COMMANDS,
     DEFAULT_MAX_INSTALL_DEPTH: () => DEFAULT_MAX_INSTALL_DEPTH,
     EXTRA_COMMANDS: () => EXTRA_COMMANDS,
+    FN_FETCH_INTERCEPTOR_SCRIPT: () => FN_FETCH_INTERCEPTOR_SCRIPT,
     RESOLVE_EXTENSIONS: () => RESOLVE_EXTENSIONS,
     ResolveError: () => ResolveError,
     SHELL_COMMANDS: () => SHELL_COMMANDS,
@@ -212,6 +1643,7 @@ var AdepWebContainer = (() => {
     TestAssertionError: () => TestAssertionError,
     UnsupportedTsSyntaxError: () => UnsupportedTsSyntaxError,
     VirtualFileSystem: () => VirtualFileSystem,
+    ViteDevError: () => ViteDevError,
     applyCompletion: () => applyCompletion,
     bootstrap: () => bootstrap,
     buildCloudFromBundle: () => buildCloudFromBundle,
@@ -227,6 +1659,7 @@ var AdepWebContainer = (() => {
     createBrowserStorageDriver: () => createBrowserStorageDriver,
     createCommandHistory: () => createCommandHistory,
     createFsPersistence: () => createFsPersistence,
+    createFunctionFetchHandler: () => createFunctionFetchHandler,
     createIdbSimKv: () => createIdbSimKv,
     createIndexedDbFsBackend: () => createIndexedDbFsBackend,
     createLocalPort: () => createLocalPort,
@@ -235,10 +1668,12 @@ var AdepWebContainer = (() => {
     createMemorySimKv: () => createMemorySimKv,
     createNpmClient: () => createNpmClient,
     createOfflineFunctionRunner: () => createOfflineFunctionRunner,
+    createRelayFetch: () => createRelayFetch,
     createRequire: () => createRequire,
     createSandboxModuleGlobals: () => createSandboxModuleGlobals,
     createTestRunner: () => createTestRunner,
     createTestScope: () => createTestScope,
+    createViteServer: () => createViteServer,
     createWorkerRuntime: () => createWorkerRuntime,
     deepEqual: () => deepEqual,
     displayPath: () => displayPath,
@@ -267,6 +1702,7 @@ var AdepWebContainer = (() => {
     resolvePackageEntry: () => resolvePackageEntry,
     restoreVfs: () => restoreVfs,
     runCollectedTests: () => runCollectedTests,
+    scanEsmSpecifiers: () => scanEsmSpecifiers,
     simDbKey: () => simDbKey,
     simStorageKey: () => simStorageKey,
     snapshotVfs: () => snapshotVfs,
@@ -489,6 +1925,9 @@ var AdepWebContainer = (() => {
     }
   };
 
+  // src/container.ts
+  init_path();
+
   // src/shell.ts
   init_path();
 
@@ -508,9 +1947,12 @@ var AdepWebContainer = (() => {
     "cd",
     "head",
     "tail",
+    "curl",
+    "wget",
     "test",
     "node",
     "js",
+    "vite",
     "help"
   ];
   var EXTRA_COMMANDS = ["npm"];
@@ -815,6 +2257,33 @@ var AdepWebContainer = (() => {
           }
           break;
         }
+        case "curl": {
+          const outcome = await this.runCurl(argv.slice(1));
+          stdout = outcome.stdout;
+          stderr = outcome.stderr;
+          exitCode = outcome.code;
+          break;
+        }
+        case "wget": {
+          const outcome = await this.runWget(argv.slice(1));
+          stdout = outcome.stdout;
+          stderr = outcome.stderr;
+          exitCode = outcome.code;
+          break;
+        }
+        case "vite": {
+          if (this.ctx.vite === void 0)
+            return {
+              code: 1,
+              stdout: "",
+              stderr: "vite: \u672A\u88C5\u914D\u524D\u7AEF\u5F00\u53D1\u670D\u52A1\u5668\uFF08bootstrap \u4F1A\u6CE8\u5165\uFF1B\u88F8 Shell \u9700\u81EA\u884C\u7ED9 ctx.vite\uFF09\n"
+            };
+          const outcome = await this.runVite(argv.slice(1));
+          stdout = outcome.stdout;
+          stderr = outcome.stderr;
+          exitCode = outcome.code;
+          break;
+        }
         default:
           stderr = `${command}: command not found
 `;
@@ -837,6 +2306,168 @@ var AdepWebContainer = (() => {
       }
       return out;
     }
+    /**
+     * `curl [选项] <url>`（常用旗标最小子集）：
+     * - 响应体默认写 stdout（可 `|` 管道 / `>` 重定向）；`-o <file>` 写 VFS 文件、`-o -` 显式 stdout；
+     * - `-i/--include` 输出响应头 + 体；`-I/--head` 发 HEAD 且只输出响应头；
+     * - `-X/--request`、`-H/--header`（可多次）、`-d/--data`（可多次，`&` 拼接，隐含 POST 与表单头）、
+     *   `-A/--user-agent`、`-u/--user`（转 Basic 认证）、`-f/--fail`（HTTP ≥400 退出码 22）；
+     * - `-s/-S/-L/-k/-g/-N/--compressed` 等常见旗标接受但无效果（仿真环境本就静默/跟随重定向/不校验证书）；
+     * - 裸主机名（`example.com/x`）按 curl 语义补 `http://`；网络故障退出码 7，用法错误 2。
+     */
+    async runCurl(args) {
+      const flags = parseCurlArgs(args);
+      if (flags.url === null) {
+        return { code: 2, stdout: "", stderr: "curl: \u672A\u63D0\u4F9B URL\uFF08\u7528\u6CD5\uFF1Acurl [\u9009\u9879] <url>\uFF09\n" };
+      }
+      const url = normalizeUrl(flags.url);
+      if (url === null)
+        return { code: 3, stdout: "", stderr: `curl: (3) URL \u683C\u5F0F\u9519\u8BEF\uFF1A${flags.url}
+` };
+      const method = flags.head ? "HEAD" : flags.method ?? (flags.data.length > 0 ? "POST" : "GET");
+      const headers = { ...flags.headers };
+      const body = flags.data.length > 0 ? flags.data.join("&") : void 0;
+      if (body !== void 0 && !("content-type" in headers)) {
+        headers["content-type"] = "application/x-www-form-urlencoded";
+      }
+      let res;
+      try {
+        res = await this.netRequest(url, {
+          method,
+          headers,
+          ...body === void 0 ? {} : { body }
+        });
+      } catch (error) {
+        if (error instanceof NetCommandError && error.kind === "no-net")
+          return { code: 1, stdout: "", stderr: `curl: ${error.message}
+` };
+        return {
+          code: 7,
+          stdout: "",
+          stderr: `curl: (7) \u65E0\u6CD5\u8FDE\u63A5\u4E3B\u673A\uFF1A${error instanceof Error ? error.message : String(error)}
+`
+        };
+      }
+      const head = flags.head || flags.include ? formatResponseHead(res) : "";
+      let stdout;
+      if (flags.output !== null && flags.output !== "-") {
+        this.ctx.vfs.writeFile(this.resolve(flags.output), res.body);
+        stdout = head;
+      } else {
+        stdout = head + (flags.head ? "" : res.body);
+      }
+      if (flags.fail && !res.ok) {
+        return { code: 22, stdout, stderr: `curl: (22) HTTP \u8BF7\u6C42\u8FD4\u56DE\u9519\u8BEF\u7801 ${res.status}
+` };
+      }
+      return { code: 0, stdout, stderr: "" };
+    }
+    /**
+     * `wget [选项] <url>`（常用旗标最小子集）：
+     * - 默认按 URL 末级路径名落 VFS 文件（目录形态落 `index.html`），过程信息走 stderr；
+     * - `-O <file>` 指定文件名、`-O -` 输出到 stdout；`-q/--quiet` 静默；`-S/--server-response` 打印响应头；
+     * - HTTP ≥400 / 网络失败退出码 1 且不落文件（与 GNU wget 默认一致）。
+     */
+    async runWget(args) {
+      const flags = parseWgetArgs(args);
+      if (flags.url === null) {
+        return { code: 1, stdout: "", stderr: "wget: \u672A\u63D0\u4F9B URL\uFF08\u7528\u6CD5\uFF1Awget [\u9009\u9879] <url>\uFF09\n" };
+      }
+      const url = normalizeUrl(flags.url);
+      if (url === null) return { code: 1, stdout: "", stderr: `wget: URL \u683C\u5F0F\u9519\u8BEF\uFF1A${flags.url}
+` };
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        return { code: 1, stdout: "", stderr: `wget: URL \u683C\u5F0F\u9519\u8BEF\uFF1A${url}
+` };
+      }
+      let res;
+      try {
+        res = await this.netRequest(url, { method: "GET" });
+      } catch (error) {
+        if (error instanceof NetCommandError && error.kind === "no-net")
+          return { code: 1, stdout: "", stderr: `wget: ${error.message}
+` };
+        const reason = error instanceof Error ? error.message : String(error);
+        return { code: 1, stdout: "", stderr: `wget: \u65E0\u6CD5\u4E0B\u8F7D ${url}\uFF1A${reason}
+` };
+      }
+      const toStdout = flags.output === "-";
+      const fileName = flags.output !== null && flags.output !== "-" ? flags.output : wgetFileName(parsed);
+      let stderr = "";
+      if (!flags.quiet) {
+        const type = res.headers["content-type"] ?? "application/octet-stream";
+        const length = res.headers["content-length"] ?? String(new TextEncoder().encode(res.body).byteLength);
+        stderr += `\u6B63\u5728\u8FDE\u63A5 ${parsed.hostname}...
+`;
+        stderr += `HTTP \u8BF7\u6C42\u5DF2\u53D1\u9001\uFF0C\u6B63\u5728\u7B49\u5F85\u54CD\u5E94... ${res.status}${res.statusText ? ` ${res.statusText}` : ""}
+`;
+        if (flags.serverResponse) stderr += formatResponseHead(res);
+        stderr += `\u957F\u5EA6\uFF1A${length} [${type}]
+`;
+        if (!toStdout) stderr += `\u6B63\u5728\u4FDD\u5B58\u5230: \u201C${fileName}\u201D
+`;
+      }
+      if (!res.ok) {
+        return { code: 1, stdout: "", stderr: `${stderr}wget: \u9519\u8BEF\uFF1A\u670D\u52A1\u5668\u8FD4\u56DE HTTP ${res.status}
+` };
+      }
+      if (toStdout) return { code: 0, stdout: res.body, stderr };
+      this.ctx.vfs.writeFile(this.resolve(fileName), res.body);
+      if (!flags.quiet) stderr += `${fileName} \u5DF2\u4FDD\u5B58 [${res.body.length} \u5B57\u8282]
+`;
+      return { code: 0, stdout: "", stderr };
+    }
+    /**
+     * `vite [子命令|目录]`：
+     * - `vite` / `vite dev [dir]`：启动浏览器内 Vite 兼容 dev server（`dir` 为 root，缺省 `/`；
+     *   `--port` 等旗标接受但无效果——端口是虚拟语义值）；
+     * - `vite stop`：停止并释放；
+     * - `vite build`：首版明确不支持（dev 语义优先），如实报错。
+     * dev server 常驻在容器层（`serverready` 事件 + HMR），命令本身立即返回——与真实
+     * vite 的前台常驻进程形态不同，属仿真终端的取舍（见 vite-dev.ts 文件头）。
+     */
+    async runVite(args) {
+      const positional = args.filter((a) => !a.startsWith("-"));
+      const sub = positional[0] ?? "";
+      if (sub === "stop") {
+        const outcome2 = await this.ctx.vite.stop();
+        return outcome2.code === 0 ? { ...outcome2, stderr: "" } : { code: outcome2.code, stdout: "", stderr: outcome2.stdout };
+      }
+      if (sub === "build")
+        return {
+          code: 1,
+          stdout: "",
+          stderr: "vite build: \u6682\u4E0D\u652F\u6301\uFF08\u6D4F\u89C8\u5668\u5185 vite \u9996\u7248\u53EA\u63D0\u4F9B dev server\uFF1B\u53D1\u5E03\u8D70\u524D\u7AEF\u53D1\u5E03\u7BA1\u7EBF\uFF09\n"
+        };
+      const rootArgs = sub === "" || sub === "dev" || sub === "serve" ? positional.slice(1) : [sub];
+      const outcome = await this.ctx.vite.start(rootArgs);
+      return outcome.code === 0 ? { ...outcome, stderr: "" } : { code: outcome.code, stdout: "", stderr: outcome.stdout };
+    }
+    /** 经 net 端口发请求；端口缺失 / 网络失败归一为 NetCommandError（curl/wget 各自映射退出码与文案）。 */
+    async netRequest(url, init) {
+      if (this.ctx.net === void 0) {
+        throw new NetCommandError(
+          "no-net",
+          "\u672A\u6CE8\u5165\u7F51\u7EDC\u7AEF\u53E3\uFF08\u6D4F\u89C8\u5668\u7AEF\u7ECF\u5E73\u53F0 HTTP \u4E2D\u7EE7\u8BBF\u95EE\uFF1Bbootstrap \u9700\u63D0\u4F9B httpRelayBaseUrl\uFF09"
+        );
+      }
+      try {
+        const res = await this.ctx.net(url, init);
+        return {
+          ok: res.ok,
+          status: res.status,
+          statusText: res.statusText,
+          headers: res.headers,
+          body: await res.text()
+        };
+      } catch (error) {
+        if (error instanceof NetCommandError) throw error;
+        throw new NetCommandError("network", error instanceof Error ? error.message : String(error));
+      }
+    }
     /**
      * 对当前输入行求 Tab 补全候选（FE-022）：命令位补内建命令名，参数位补 VFS 路径。
      * 无候选不抛错（Tab 不该让终端报错），由调用方决定「不响应」还是「列出可能项」。
@@ -850,6 +2481,200 @@ var AdepWebContainer = (() => {
       return join(this.ctx.getCwd(), target);
     }
   };
+  var NetCommandError = class extends Error {
+    constructor(kind, message) {
+      super(message);
+      this.kind = kind;
+      this.name = "NetCommandError";
+    }
+  };
+  var CURL_BOOLEAN_NOOP = /* @__PURE__ */ new Set([
+    "-s",
+    "--silent",
+    "-S",
+    "--show-error",
+    "-L",
+    "--location",
+    "-k",
+    "--insecure",
+    "-g",
+    "--globoff",
+    "-N",
+    "--no-buffer",
+    "--compressed",
+    "-#",
+    "--progress-bar",
+    "-v",
+    "--verbose",
+    "-G",
+    "--get"
+  ]);
+  var WGET_BOOLEAN_NOOP = /* @__PURE__ */ new Set([
+    "--no-check-certificate",
+    "-nc",
+    "--no-clobber",
+    "-c",
+    "--continue",
+    "-nv",
+    "--no-verbose",
+    "--content-on-error"
+  ]);
+  function matchValueFlag(arg, name, longNames, consume) {
+    if (arg === name || longNames.includes(arg)) return { matched: true, value: consume() };
+    for (const long of longNames) {
+      if (arg.startsWith(`${long}=`)) return { matched: true, value: arg.slice(long.length + 1) };
+    }
+    return { matched: false, value: null };
+  }
+  function expandShortArgs(args, valueFlags) {
+    const out = [];
+    for (const arg of args) {
+      const cluster = /^-([A-Za-z]+)$/.exec(arg);
+      if (cluster === null) {
+        out.push(arg);
+        continue;
+      }
+      const chars = cluster[1];
+      for (let j = 0; j < chars.length; j++) {
+        const c = chars[j];
+        out.push(`-${c}`);
+        if (valueFlags.has(c)) {
+          const rest = chars.slice(j + 1);
+          if (rest !== "") out.push(rest);
+          break;
+        }
+      }
+    }
+    return out;
+  }
+  function parseCurlArgs(rawArgs) {
+    const args = expandShortArgs(rawArgs, /* @__PURE__ */ new Set(["X", "H", "d", "o", "A", "u", "m"]));
+    const flags = {
+      url: null,
+      method: null,
+      headers: {},
+      data: [],
+      include: false,
+      head: false,
+      output: null,
+      fail: false
+    };
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      const consume = () => {
+        const v = args[i + 1];
+        if (v !== void 0) i++;
+        return v ?? "";
+      };
+      let m = matchValueFlag(arg, "-X", ["--request"], consume);
+      if (m.matched) {
+        flags.method = (m.value ?? "").toUpperCase();
+        continue;
+      }
+      m = matchValueFlag(arg, "-H", ["--header"], consume);
+      if (m.matched) {
+        const raw = m.value ?? "";
+        const colon = raw.indexOf(":");
+        if (colon > 0)
+          flags.headers[raw.slice(0, colon).trim().toLowerCase()] = raw.slice(colon + 1).trim();
+        continue;
+      }
+      m = matchValueFlag(arg, "-A", ["--user-agent"], consume);
+      if (m.matched) {
+        flags.headers["user-agent"] = m.value ?? "";
+        continue;
+      }
+      m = matchValueFlag(arg, "-u", ["--user"], consume);
+      if (m.matched) {
+        flags.headers["authorization"] = `Basic ${btoa(m.value ?? "")}`;
+        continue;
+      }
+      m = matchValueFlag(
+        arg,
+        "-d",
+        ["--data", "--data-raw", "--data-binary", "--data-urlencode"],
+        consume
+      );
+      if (m.matched) {
+        flags.data.push(m.value ?? "");
+        continue;
+      }
+      m = matchValueFlag(arg, "-o", ["--output"], consume);
+      if (m.matched) {
+        flags.output = m.value;
+        continue;
+      }
+      m = matchValueFlag(arg, "-m", ["--max-time", "--connect-timeout"], consume);
+      if (m.matched) continue;
+      if (arg === "-i" || arg === "--include") {
+        flags.include = true;
+        continue;
+      }
+      if (arg === "-I" || arg === "--head") {
+        flags.head = true;
+        continue;
+      }
+      if (arg === "-f" || arg === "--fail") {
+        flags.fail = true;
+        continue;
+      }
+      if (CURL_BOOLEAN_NOOP.has(arg) || arg.startsWith("-")) continue;
+      if (flags.url === null) flags.url = arg;
+    }
+    return flags;
+  }
+  function parseWgetArgs(rawArgs) {
+    const args = expandShortArgs(rawArgs, /* @__PURE__ */ new Set(["O"]));
+    const flags = { url: null, output: null, quiet: false, serverResponse: false };
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      const consume = () => {
+        const v = args[i + 1];
+        if (v !== void 0) i++;
+        return v ?? "";
+      };
+      const m = matchValueFlag(arg, "-O", ["--output-document"], consume);
+      if (m.matched) {
+        flags.output = m.value;
+        continue;
+      }
+      if (arg === "-q" || arg === "--quiet") {
+        flags.quiet = true;
+        continue;
+      }
+      if (arg === "-S" || arg === "--server-response") {
+        flags.serverResponse = true;
+        continue;
+      }
+      if (WGET_BOOLEAN_NOOP.has(arg) || arg.startsWith("-")) continue;
+      if (flags.url === null) flags.url = arg;
+    }
+    return flags;
+  }
+  function normalizeUrl(raw) {
+    if (raw.startsWith("/")) return null;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return raw;
+    return `http://${raw}`;
+  }
+  function formatResponseHead(res) {
+    const reason = res.statusText !== "" ? ` ${res.statusText}` : "";
+    let head = `HTTP/1.1 ${res.status}${reason}\r
+`;
+    for (const [key, value] of Object.entries(res.headers)) head += `${key}: ${value}\r
+`;
+    return `${head}\r
+`;
+  }
+  function wgetFileName(url) {
+    const segments = url.pathname.split("/").filter((s) => s !== "");
+    const last = segments.length === 0 ? void 0 : segments[segments.length - 1];
+    if (last === void 0) return "index.html";
+    try {
+      return decodeURIComponent(last);
+    } catch {
+      return last;
+    }
+  }
 
   // src/tar.ts
   var BLOCK = 512;
@@ -874,237 +2699,72 @@ var AdepWebContainer = (() => {
   }
   function assertSafePath(path) {
     if (path === "" || path.startsWith("/") || path.startsWith("\\"))
-      throw new Error(`tar \u6761\u76EE\u8DEF\u5F84\u975E\u6CD5\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u6216\u4E3A\u7A7A\uFF09\uFF1A"${path}"`);
-    for (const segment of path.split("/")) {
-      if (segment === "..") throw new Error(`tar \u6761\u76EE\u8DEF\u5F84\u542B ".." \u7A7F\u8D8A\uFF0C\u5DF2\u62D2\u7EDD\uFF1A"${path}"`);
-    }
-  }
-  async function gunzip(bytes) {
-    if (bytes.length < 2 || bytes[0] !== GZIP_MAGIC_0 || bytes[1] !== GZIP_MAGIC_1) {
-      throw new Error("tarball \u4E0D\u662F gzip \u6570\u636E\uFF08\u7F3A\u5C11 1f 8b \u9B54\u6570\uFF09\uFF0C\u65E0\u6CD5\u89E3\u5305");
-    }
-    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
-    const buffer = await new Response(stream).arrayBuffer();
-    return new Uint8Array(buffer);
-  }
-  function unpackTar(bytes) {
-    const entries = [];
-    let offset = 0;
-    let longName = null;
-    while (offset + BLOCK <= bytes.length) {
-      const header = bytes.subarray(offset, offset + BLOCK);
-      if (header.every((byte) => byte === 0)) break;
-      const typeflag = String.fromCharCode(header[156]);
-      const size = parseOctalSize(header, 124, 12);
-      let name = readString(bytes, offset, 100);
-      const prefix = readString(bytes, offset + 345, 155);
-      if (prefix !== "") name = `${prefix}/${name}`;
-      const dataStart = offset + BLOCK;
-      const data = bytes.subarray(dataStart, dataStart + size);
-      offset = dataStart + Math.ceil(size / BLOCK) * BLOCK;
-      if (typeflag === "L") {
-        longName = new TextDecoder("utf-8").decode(data).replace(/\0+$/g, "").trim();
-        continue;
-      }
-      if (typeflag === "x" || typeflag === "g") continue;
-      if (typeflag === "5") continue;
-      if (typeflag !== "0" && typeflag !== "\0") {
-        throw new Error(`tar \u6761\u76EE\u7C7B\u578B "${typeflag}" \u4E0D\u652F\u6301\uFF08\u53EA\u63A5\u53D7\u666E\u901A\u6587\u4EF6\u4E0E\u76EE\u5F55\uFF09\uFF1A"${name}"`);
-      }
-      if (longName !== null) {
-        name = longName;
-        longName = null;
-      }
-      assertSafePath(name);
-      entries.push({ path: name, contents: new Uint8Array(data) });
-    }
-    return entries;
-  }
-  async function unpackNpmTarball(bytes) {
-    const tar = unpackTar(await gunzip(bytes));
-    if (tar.length === 0) throw new Error("tarball \u89E3\u5305\u540E\u4E3A\u7A7A\uFF0C\u6CA1\u6709\u4EFB\u4F55\u6587\u4EF6\u6761\u76EE");
-    const out = [];
-    for (const entry of tar) {
-      if (!entry.path.startsWith("package/")) {
-        throw new Error(
-          `tarball \u9876\u5C42\u76EE\u5F55\u5F02\u5E38\uFF08npm registry \u5F52\u6863\u5E94\u5168\u90E8\u4F4D\u4E8E "package/" \u4E0B\uFF09\uFF1A"${entry.path}"`
-        );
-      }
-      out.push({ path: entry.path.slice("package/".length), contents: entry.contents });
-    }
-    if (!out.some((entry) => entry.path === "package.json")) {
-      throw new Error("tarball \u7F3A\u5C11 package.json\uFF0C\u62D2\u7EDD\u89E3\u5305");
-    }
-    return out;
-  }
-
-  // src/node-resolve.ts
-  init_path();
-  var RESOLVE_EXTENSIONS = [".js", ".mjs", ".cjs", ".json"];
-  var ResolveError = class extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "ResolveError";
-    }
-  };
-  function parsePackageMeta(content, context) {
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      throw new ResolveError(`${context} \u4E0D\u662F\u5408\u6CD5 JSON`);
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new ResolveError(`${context} \u9876\u5C42\u5FC5\u987B\u662F\u5BF9\u8C61`);
-    }
-    return parsed;
-  }
-  function withinPackage(pkgDirAbs, rel, context) {
-    if (typeof rel !== "string" || rel === "") {
-      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84\u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
-    }
-    if (!rel.startsWith("./") && !rel.startsWith("../") && rel.startsWith("/")) {
-      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84 "${rel}" \u5FC5\u987B\u662F\u5305\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF08\u4EE5 ./ \u5F00\u5934\uFF09`);
-    }
-    const abs = join(pkgDirAbs, rel.startsWith(".") ? rel : `./${rel}`);
-    if (!abs.startsWith(`${pkgDirAbs}/`)) {
-      throw new ResolveError(`${context}\uFF1A\u5165\u53E3\u8DEF\u5F84 "${rel}" \u8D8A\u51FA\u5305\u76EE\u5F55\uFF0C\u5DF2\u62D2\u7EDD`);
-    }
-    return abs;
-  }
-  function resolvePackageEntry(meta, pkgDirAbs, condition) {
-    const context = `\u5305 ${meta.name ?? meta.version ?? pkgDirAbs} \u7684 exports/main \u58F0\u660E`;
-    const exp = meta.exports;
-    if (exp !== void 0 && exp !== null) {
-      if (typeof exp === "string") return withinPackage(pkgDirAbs, exp, context);
-      if (typeof exp !== "object" || Array.isArray(exp)) {
-        throw new ResolveError(`${context} \u5F62\u6001\u4E0D\u652F\u6301\uFF08exports \u53EA\u80FD\u662F\u5B57\u7B26\u4E32\u6216\u5BF9\u8C61\uFF09`);
-      }
-      const dot = exp["."];
-      if (dot === void 0) {
-        throw new ResolveError(
-          `${context} \u53EA\u58F0\u660E\u4E86\u5B50\u8DEF\u5F84\u6620\u5C04\u3001\u6CA1\u6709 "." \u5165\u53E3\uFF0C\u5F53\u524D\u4EC5\u652F\u6301 "." \u4E0E\u5B57\u7B26\u4E32\u5F62\u6001`
-        );
-      }
-      if (typeof dot === "string") return withinPackage(pkgDirAbs, dot, context);
-      if (dot === null)
-        throw new ResolveError(`${context}\uFF1Aexports["."] \u4E3A null\uFF08\u8BE5\u6761\u4EF6\u88AB\u663E\u5F0F\u6392\u9664\uFF09\uFF0C\u65E0\u6CD5\u89E3\u6790\u5165\u53E3`);
-      if (typeof dot !== "object" || Array.isArray(dot)) {
-        throw new ResolveError(`${context}\uFF1Aexports["."] \u5F62\u6001\u4E0D\u652F\u6301\uFF08\u4EC5\u63A5\u53D7\u5B57\u7B26\u4E32\u6216\u6761\u4EF6\u5BF9\u8C61\uFF09`);
-      }
-      const conditions = dot;
-      const order = condition === "import" ? ["import", "node", "default"] : ["require", "node", "default"];
-      for (const key of order) {
-        const value = conditions[key];
-        if (typeof value === "string") return withinPackage(pkgDirAbs, value, context);
-        if (value !== void 0 && (typeof value !== "object" || value === null)) {
-          throw new ResolveError(
-            `${context}\uFF1Aexports["."]["${key}"] \u5F62\u6001\u4E0D\u652F\u6301\uFF08\u4EC5\u63A5\u53D7\u5B57\u7B26\u4E32\u6216 null\uFF09`
-          );
-        }
-      }
-      throw new ResolveError(
-        `${context}\uFF1Aexports["."] \u6761\u4EF6\u5BF9\u8C61\u91CC\u6CA1\u6709 ${condition}/node/default \u5B57\u7B26\u4E32\u5165\u53E3\uFF08\u5B50\u8DEF\u5F84/\u5D4C\u5957\u6761\u4EF6\u4E0D\u652F\u6301\uFF09`
-      );
-    }
-    if (meta.main !== void 0) {
-      if (typeof meta.main !== "string") {
-        throw new ResolveError(`${context}\uFF1Amain \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
-      }
-      return withinPackage(pkgDirAbs, meta.main, context);
-    }
-    return join(pkgDirAbs, "index.js");
-  }
-  function splitPackageSpecifier(spec) {
-    if (spec.startsWith("@")) {
-      const first = spec.indexOf("/");
-      if (first === -1) return { name: spec, subpath: "" };
-      const second = spec.indexOf("/", first + 1);
-      if (second === -1) return { name: spec, subpath: "" };
-      return { name: spec.slice(0, second), subpath: spec.slice(second + 1) };
-    }
-    const slash = spec.indexOf("/");
-    if (slash === -1) return { name: spec, subpath: "" };
-    return { name: spec.slice(0, slash), subpath: spec.slice(slash + 1) };
-  }
-  function asFile(fs, baseAbs) {
-    if (fs.exists(baseAbs) && !fsIsDirectory(fs, baseAbs)) return baseAbs;
-    for (const ext of RESOLVE_EXTENSIONS) {
-      const candidate = `${baseAbs}${ext}`;
-      if (fs.exists(candidate) && !fsIsDirectory(fs, candidate)) return candidate;
+      throw new Error(`tar \u6761\u76EE\u8DEF\u5F84\u975E\u6CD5\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u6216\u4E3A\u7A7A\uFF09\uFF1A"${path}"`);
+    for (const segment of path.split("/")) {
+      if (segment === "..") throw new Error(`tar \u6761\u76EE\u8DEF\u5F84\u542B ".." \u7A7F\u8D8A\uFF0C\u5DF2\u62D2\u7EDD\uFF1A"${path}"`);
     }
-    return null;
   }
-  function asDirectory(fs, dirAbs) {
-    if (!fs.exists(dirAbs) || !fsIsDirectory(fs, dirAbs)) return null;
-    const manifest = `${dirAbs}/package.json`;
-    if (fs.exists(manifest)) {
-      const meta = parsePackageMeta(fs.readFile(manifest), manifest);
-      const entry = resolvePackageEntry(meta, dirAbs, "require");
-      const hit = asFile(fs, entry);
-      if (hit !== null) return hit;
+  async function gunzip(bytes) {
+    if (bytes.length < 2 || bytes[0] !== GZIP_MAGIC_0 || bytes[1] !== GZIP_MAGIC_1) {
+      throw new Error("tarball \u4E0D\u662F gzip \u6570\u636E\uFF08\u7F3A\u5C11 1f 8b \u9B54\u6570\uFF09\uFF0C\u65E0\u6CD5\u89E3\u5305");
     }
-    return asFile(fs, join(dirAbs, "index"));
-  }
-  function fsIsDirectory(fs, path) {
-    const probe = fs;
-    return probe.isDirectory?.(path) ?? false;
+    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+    const buffer = await new Response(stream).arrayBuffer();
+    return new Uint8Array(buffer);
   }
-  function resolveImport(fs, specifier, fromFileAbs, condition = "require") {
-    if (specifier === "") throw new ResolveError("\u7A7A\u8BF4\u660E\u7B26\uFF1A\u65E0\u6CD5\u89E3\u6790\u6A21\u5757");
-    if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const base = join(dirname(fromFileAbs), specifier);
-      const hit = asFile(fs, base) ?? asDirectory(fs, base);
-      if (hit === null) {
-        throw new ResolveError(
-          `\u627E\u4E0D\u5230\u76F8\u5BF9\u6A21\u5757 "${specifier}"\uFF08\u81EA ${dirname(fromFileAbs)}\uFF0C\u8BD5\u8FC7\u6269\u5C55\u540D ${RESOLVE_EXTENSIONS.join("/")} \u4E0E\u76EE\u5F55\u7D22\u5F15\uFF09`
-        );
+  function unpackTar(bytes) {
+    const entries = [];
+    let offset = 0;
+    let longName = null;
+    while (offset + BLOCK <= bytes.length) {
+      const header = bytes.subarray(offset, offset + BLOCK);
+      if (header.every((byte) => byte === 0)) break;
+      const typeflag = String.fromCharCode(header[156]);
+      const size = parseOctalSize(header, 124, 12);
+      let name = readString(bytes, offset, 100);
+      const prefix = readString(bytes, offset + 345, 155);
+      if (prefix !== "") name = `${prefix}/${name}`;
+      const dataStart = offset + BLOCK;
+      const data = bytes.subarray(dataStart, dataStart + size);
+      offset = dataStart + Math.ceil(size / BLOCK) * BLOCK;
+      if (typeflag === "L") {
+        longName = new TextDecoder("utf-8").decode(data).replace(/\0+$/g, "").trim();
+        continue;
       }
-      return hit;
-    }
-    if (specifier.startsWith("/")) {
-      const hit = asFile(fs, specifier) ?? asDirectory(fs, specifier);
-      if (hit === null) throw new ResolveError(`\u627E\u4E0D\u5230\u7EDD\u5BF9\u8DEF\u5F84\u6A21\u5757 "${specifier}"`);
-      return hit;
-    }
-    const { name, subpath } = splitPackageSpecifier(specifier);
-    if (name.startsWith("node:")) {
-      throw new ResolveError(`\u6D4F\u89C8\u5668\u6C99\u7BB1\u4E0D\u63D0\u4F9B Node \u5185\u5EFA\u6A21\u5757 "${specifier}"`);
+      if (typeflag === "x" || typeflag === "g") continue;
+      if (typeflag === "5") continue;
+      if (typeflag !== "0" && typeflag !== "\0") {
+        throw new Error(`tar \u6761\u76EE\u7C7B\u578B "${typeflag}" \u4E0D\u652F\u6301\uFF08\u53EA\u63A5\u53D7\u666E\u901A\u6587\u4EF6\u4E0E\u76EE\u5F55\uFF09\uFF1A"${name}"`);
+      }
+      if (longName !== null) {
+        name = longName;
+        longName = null;
+      }
+      assertSafePath(name);
+      entries.push({ path: name, contents: new Uint8Array(data) });
     }
-    let dir = dirname(fromFileAbs);
-    for (; ; ) {
-      const pkgDir = join(dir, "node_modules", name);
-      if (fs.exists(pkgDir) && fsIsDirectory(fs, pkgDir)) {
-        if (subpath === "") {
-          const manifest = `${pkgDir}/package.json`;
-          if (fs.exists(manifest)) {
-            const meta = parsePackageMeta(fs.readFile(manifest), manifest);
-            const entry = resolvePackageEntry(meta, pkgDir, condition);
-            const hit = asFile(fs, entry) ?? asDirectory(fs, entry);
-            if (hit !== null) return hit;
-          } else {
-            const hit = asFile(fs, join(pkgDir, "index")) ?? asDirectory(fs, pkgDir);
-            if (hit !== null) return hit;
-          }
-        } else {
-          const base = join(pkgDir, subpath);
-          const hit = asFile(fs, base) ?? asDirectory(fs, base);
-          if (hit !== null) return hit;
-        }
-        throw new ResolveError(
-          `\u5728 ${pkgDir} \u627E\u5230\u4E86\u5305 "${name}"\uFF0C\u4F46\u89E3\u6790\u8BF4\u660E\u7B26 "${specifier}" \u5931\u8D25\uFF08\u5B50\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF0C\u6216 exports/main \u6307\u5411\u7684\u5165\u53E3\u6587\u4EF6\u7F3A\u5931\uFF09`
+    return entries;
+  }
+  async function unpackNpmTarball(bytes) {
+    const tar = unpackTar(await gunzip(bytes));
+    if (tar.length === 0) throw new Error("tarball \u89E3\u5305\u540E\u4E3A\u7A7A\uFF0C\u6CA1\u6709\u4EFB\u4F55\u6587\u4EF6\u6761\u76EE");
+    const out = [];
+    for (const entry of tar) {
+      if (!entry.path.startsWith("package/")) {
+        throw new Error(
+          `tarball \u9876\u5C42\u76EE\u5F55\u5F02\u5E38\uFF08npm registry \u5F52\u6863\u5E94\u5168\u90E8\u4F4D\u4E8E "package/" \u4E0B\uFF09\uFF1A"${entry.path}"`
         );
       }
-      const parent = dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
+      out.push({ path: entry.path.slice("package/".length), contents: entry.contents });
     }
-    throw new ResolveError(
-      `\u627E\u4E0D\u5230\u5305 "${specifier}"\uFF1A${dirname(fromFileAbs)} \u53CA\u5176\u5404\u7EA7\u7236\u76EE\u5F55\u4E0B\u90FD\u6CA1\u6709 node_modules/${name}\uFF08\u5148\u5728\u7EC8\u7AEF npm install ${name}\uFF09`
-    );
+    if (!out.some((entry) => entry.path === "package.json")) {
+      throw new Error("tarball \u7F3A\u5C11 package.json\uFF0C\u62D2\u7EDD\u89E3\u5305");
+    }
+    return out;
   }
 
   // src/npm-client.ts
+  init_node_resolve();
   var DEFAULT_MAX_INSTALL_DEPTH = 5;
   var defaultFetch = (url, init) => globalThis.fetch(url, init).then((res) => res);
   function parseSpec(spec) {
@@ -1255,7 +2915,58 @@ var AdepWebContainer = (() => {
     };
   }
 
+  // src/relay-fetch.ts
+  var defaultFetch2 = (url, init) => globalThis.fetch(url, init).then((res) => res);
+  function createRelayFetch(options) {
+    const fetchImpl = options.fetchImpl ?? defaultFetch2;
+    const base = options.baseUrl.replace(/\/+$/, "");
+    return async (url, init) => {
+      let res;
+      try {
+        res = await fetchImpl(`${base}/fetch`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            url,
+            method: init?.method ?? "GET",
+            ...init?.headers === void 0 ? {} : { headers: init.headers },
+            ...init?.body === void 0 ? {} : { body: init.body }
+          })
+        });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`HTTP \u4E2D\u7EE7\u4E0D\u53EF\u8FBE\uFF08${base}/fetch\uFF0C${reason}\uFF09`, { cause: error });
+      }
+      if (!res.ok) {
+        let message = `HTTP \u4E2D\u7EE7\u8FD4\u56DE ${res.status}`;
+        try {
+          const data = await res.json();
+          if (data.error?.message) message = data.error.message;
+        } catch {
+        }
+        throw new Error(message);
+      }
+      const env = await res.json();
+      return {
+        ok: env.ok,
+        status: env.status,
+        statusText: env.statusText,
+        headers: env.headers ?? {},
+        text: async () => env.body,
+        json: async () => JSON.parse(env.body),
+        arrayBuffer: async () => {
+          const bytes = new TextEncoder().encode(env.body);
+          return bytes.buffer.slice(
+            bytes.byteOffset,
+            bytes.byteOffset + bytes.byteLength
+          );
+        }
+      };
+    };
+  }
+
   // src/module-loader.ts
+  init_node_resolve();
   function interopDefault(value) {
     if (value !== null && typeof value === "object" && "__esModule" in value) {
       return value.default;
@@ -1461,614 +3172,8 @@ self.onmessage = async (event) => {
     };
   }
 
-  // src/strip-types.ts
-  var UnsupportedTsSyntaxError = class extends Error {
-    constructor(construct, line) {
-      super(`\u4E0D\u53D7\u652F\u6301\u7684 TypeScript \u8BED\u6CD5\uFF1A${construct}\uFF08\u7B2C ${line} \u884C\uFF09\u2014\u2014\u6D4F\u89C8\u5668\u6D4B\u8BD5\u6C99\u7BB1\u53EA\u64E6\u9664\u7C7B\u578B\u6807\u6CE8`);
-      this.construct = construct;
-      this.line = line;
-      this.name = "UnsupportedTsSyntaxError";
-    }
-  };
-  var IDENT_START = /[A-Za-z_$]/;
-  var IDENT_PART = /[A-Za-z0-9_$]/;
-  var DECL_KEYWORDS = /* @__PURE__ */ new Set(["const", "let", "var"]);
-  var TS_MODIFIERS = /* @__PURE__ */ new Set([
-    "private",
-    "protected",
-    "public",
-    "readonly",
-    "abstract",
-    "override",
-    "declare"
-  ]);
-  var ANNOTATION_LEADERS = /* @__PURE__ */ new Set(["(", ",", "{", ";", "erased", "modifier"]);
-  function isAnnotationLeader(token) {
-    return ANNOTATION_LEADERS.has(token) || TS_MODIFIERS.has(token);
-  }
-  var Eraser = class {
-    constructor(src) {
-      this.src = src;
-      this.chars = [...src];
-    }
-    chars;
-    tokens = [];
-    frames = [];
-    /** 刚消费 `class` 头：下一个 `{` 是类体起始。 */
-    pendingClassBody = false;
-    /** 刚消费 `=>`：其后的 `(` 是箭头函数参数列表（声明位）。 */
-    afterArrow = false;
-    /** 刚消费 `function` 关键字：其后的标识符是函数名，再后是参数列表。 */
-    afterFunctionKeyword = false;
-    /** 最近一次 `)` 闭合的是不是参数列表（返回值标注判据）。 */
-    justClosedDeclareParen = false;
-    i = 0;
-    run() {
-      while (this.i < this.src.length) {
-        if (/\s/.test(this.ch())) {
-          this.i++;
-          continue;
-        }
-        if (this.copyTrivia()) continue;
-        if (this.copyLiteral()) continue;
-        if (this.copyRegexIfNeeded()) continue;
-        if (this.readNumber()) continue;
-        const word = this.readWord();
-        if (word !== null) this.handleWord(word);
-        else this.handlePunctuation();
-      }
-      return this.chars.join("");
-    }
-    /* ———————————————————— 游标原语 ———————————————————— */
-    ch(offset = 0) {
-      return this.src[this.i + offset] ?? "";
-    }
-    /** 回看第 `back` 个显著 token（1 = 最近一个）。 */
-    tokenAt(back) {
-      return this.tokens[this.tokens.length - back] ?? "";
-    }
-    /** 擦除结果里 `from` 往前的最后一个非空白字符（看的是已擦除文本，不是原文）。 */
-    prevSignificantChar(from) {
-      for (let j = from; j >= 0; j--) {
-        const c = this.chars[j];
-        if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") return c;
-      }
-      return "";
-    }
-    /** 擦除 `[from, to)`：填等长空格，换行照抄——擦完行号与原文件一致。 */
-    erase(from, to) {
-      for (let j = Math.max(from, 0); j < to; j++) this.chars[j] = this.src[j] === "\n" ? "\n" : " ";
-    }
-    pushToken(token) {
-      this.afterArrow = token === "=>";
-      this.afterFunctionKeyword = token === "function";
-      this.tokens.push(token);
-    }
-    /** 数字面量整段消费（否则 `1.5` 会被拆成 `1` `.` `5`，`.` 参与判据时误判）。 */
-    readNumber() {
-      if (!/[0-9]/.test(this.ch())) return false;
-      let end = this.i;
-      while (end < this.src.length && /[0-9a-fA-FxXoObB._]/.test(this.src[end])) end++;
-      this.i = end;
-      this.pushToken("number");
-      return true;
-    }
-    readWord() {
-      if (!IDENT_START.test(this.ch())) return null;
-      let end = this.i;
-      while (end < this.src.length && IDENT_PART.test(this.src[end])) end++;
-      const word = this.src.slice(this.i, end);
-      this.i = end;
-      this.pushToken(word);
-      return word;
-    }
-    /* —————————————— 字面量与注释：整段跳过（内容永不参与判定） —————————————— */
-    copyTrivia() {
-      const head = this.ch();
-      const next = this.ch(1);
-      if (head === "/" && next === "/") {
-        while (this.i < this.src.length && this.ch() !== "\n") this.i++;
-        return true;
-      }
-      if (head === "/" && next === "*") {
-        const end = this.src.indexOf("*/", this.i + 2);
-        this.i = end === -1 ? this.src.length : end + 2;
-        return true;
-      }
-      return false;
-    }
-    copyLiteral() {
-      const head = this.ch();
-      if (head !== "'" && head !== '"' && head !== "`") return false;
-      this.i = head === "`" ? this.scanTemplate(this.i) : this.scanQuoted(this.i);
-      this.pushToken(head === "`" ? "template" : "string");
-      return true;
-    }
-    /** 引号串结束下标（未闭合则到行尾，把真实的语法错误留给求值期）。 */
-    scanQuoted(start) {
-      const quote = this.src[start];
-      let j = start + 1;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "\\") j += 2;
-        else if (c === quote) return j + 1;
-        else if (c === "\n") return j;
-        else j++;
-      }
-      return this.src.length;
-    }
-    /** 模板串结束下标（`${}` 内按大括号配平，内层字符串 / 模板一并识别）。 */
-    scanTemplate(start) {
-      let j = start + 1;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "\\") j += 2;
-        else if (c === "`") return j + 1;
-        else if (c === "$" && this.src[j + 1] === "{") j = this.scanInterpolation(j + 2);
-        else j++;
-      }
-      return this.src.length;
-    }
-    scanInterpolation(start) {
-      let depth = 1;
-      let j = start;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "\\") j += 2;
-        else if (c === "'" || c === '"') j = this.scanQuoted(j);
-        else if (c === "`") j = this.scanTemplate(j);
-        else if (c === "{") {
-          depth++;
-          j++;
-        } else if (c === "}") {
-          depth--;
-          j++;
-          if (depth === 0) return j;
-        } else j++;
-      }
-      return this.src.length;
-    }
-    /**
-     * 正则字面量：`/` 只在「运算符位」才是正则起始（前一个显著字符不是值结尾）。
-     * 判不准时按除号处理——除号后面不会有需要擦除的类型标注，最坏只是漏擦。
-     * 有了这条，`const url = /https:\/\//` 里的 `:` 与 `//` 才不会被人当语法（恒等用例之一）。
-     */
-    copyRegexIfNeeded() {
-      if (this.ch() !== "/") return false;
-      const prev = this.prevSignificantChar(this.i - 1);
-      const valueEnding = prev !== "" && (IDENT_PART.test(prev) || prev === ")" || prev === "]" || prev === "}" || prev === '"' || prev === "'" || prev === "`");
-      if (valueEnding) return false;
-      const end = this.scanRegex(this.i);
-      if (end === null) return false;
-      this.i = end;
-      this.pushToken("regex");
-      return true;
-    }
-    scanRegex(start) {
-      let j = start + 1;
-      let inClass = false;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "\\") {
-          j += 2;
-          continue;
-        }
-        if (c === "\n") return null;
-        if (c === "[") inClass = true;
-        else if (c === "]") inClass = false;
-        else if (c === "/" && !inClass) {
-          j++;
-          while (j < this.src.length && /[a-z]/i.test(this.src[j])) j++;
-          return j;
-        }
-        j++;
-      }
-      return null;
-    }
-    /* ———————————————— 关键字与声明结构 ———————————————— */
-    handleWord(word) {
-      const start = this.i - word.length;
-      if (this.tokenAt(2) === ".") {
-        this.consumeGenericsAfterName();
-        return;
-      }
-      switch (word) {
-        case "interface": {
-          const after = this.skipWhitespaceFrom(this.skipNameAndParams(start + word.length));
-          if (after === null || this.src[after] !== "{") return;
-          const end = this.scanBalanced(after, "{", "}");
-          this.erase(start, end);
-          this.i = end;
-          this.pushToken("erased");
-          return;
-        }
-        case "type": {
-          const after = this.skipWhitespaceFrom(this.skipNameAndParams(this.i));
-          if (after === null || this.src[after] !== "=") return;
-          const end = this.scanTypeExpression(after + 1, true);
-          this.erase(start, end);
-          this.i = end;
-          this.pushToken("erased");
-          return;
-        }
-        case "import":
-        case "export": {
-          if (!/^\s+type\b/.test(this.src.slice(this.i))) return;
-          const after = this.skipNameAndParams(this.i);
-          if (after === null) return;
-          const end = this.scanStatementEnd(after);
-          this.erase(start, end);
-          this.i = end;
-          this.pushToken("erased");
-          return;
-        }
-        case "enum":
-        case "namespace":
-          throw new UnsupportedTsSyntaxError(word, this.lineAt(start));
-        case "implements": {
-          let j = this.i;
-          while (j < this.src.length && this.src[j] !== "{" && this.src[j] !== ";") j++;
-          this.erase(start, j);
-          this.i = j;
-          this.pushToken("erased");
-          return;
-        }
-        case "class":
-          this.pendingClassBody = true;
-          return;
-        case "as":
-        case "satisfies": {
-          if (this.tokenAt(2) === "*" || this.tokenAt(2) === "type") return;
-          const nextChar = this.skipWhitespaceFrom(this.i);
-          if (nextChar === null || "=,:]})".includes(this.src[nextChar])) return;
-          const end = this.scanTypeExpression(this.i, false);
-          this.erase(start, end);
-          this.i = end;
-          return;
-        }
-        default: {
-          if (TS_MODIFIERS.has(word) && this.inClassBody()) {
-            const next = this.peekWord();
-            if (next === "" || /[{(=]/.test(next[0])) return;
-            this.erase(start, this.i);
-            this.pushToken("modifier");
-            return;
-          }
-          this.consumeGenericsAfterName();
-        }
-      }
-    }
-    peekWord() {
-      let j = this.i;
-      while (j < this.src.length && /\s/.test(this.src[j])) j++;
-      let end = j;
-      while (end < this.src.length && IDENT_PART.test(this.src[end])) end++;
-      return this.src.slice(j, end);
-    }
-    lineAt(index) {
-      let line = 1;
-      for (let j = 0; j < index; j++) if (this.src[j] === "\n") line++;
-      return line;
-    }
-    /** `:` 之前紧邻的是不是 `)`（返回值标注位；用于决定是否允许顶层 `=>` 续读）。 */
-    lastSignificantCharIsCloseParen(at) {
-      return this.prevSignificantChar(at - 1) === ")";
-    }
-    inClassBody() {
-      return this.frames[this.frames.length - 1]?.classBody === true;
-    }
-    /** 当前帧是不是声明位（参数列表 / 类体）——只有这里才允许把 `:` 判成标注。 */
-    inDeclarePosition() {
-      const frame = this.frames[this.frames.length - 1];
-      return frame !== void 0 && (frame.declare || frame.classBody);
-    }
-    /* ———————————————— 标点与括号帧 ———————————————— */
-    handlePunctuation() {
-      const c = this.ch();
-      const start = this.i;
-      if (c === "(" || c === "{" || c === "[") {
-        const frame = {
-          kind: c === "(" ? "paren" : c === "{" ? "brace" : "bracket",
-          declare: false,
-          classBody: false
-        };
-        if (c === "{" && this.pendingClassBody) {
-          frame.classBody = true;
-          this.pendingClassBody = false;
-        }
-        if (c === "(" && this.isDeclareParen(start)) frame.declare = true;
-        this.frames.push(frame);
-        this.i++;
-        this.pushToken(c);
-        return;
-      }
-      if (c === ")" || c === "}" || c === "]") {
-        const closed = this.frames.pop();
-        if (closed?.kind === "paren") this.justClosedDeclareParen = closed.declare;
-        this.i++;
-        this.pushToken(c);
-        return;
-      }
-      if (c === ":") {
-        if (this.ch(1) === ":") {
-          this.i++;
-          this.pushToken(":");
-          return;
-        }
-        const returnType = this.isAnnotationColon(start) && this.lastSignificantCharIsCloseParen(start);
-        if (returnType || this.isAnnotationColon(start)) {
-          const end = this.scanTypeExpression(start + 1, false, returnType);
-          this.erase(start, end);
-          this.i = end;
-          this.pushToken("erased");
-          return;
-        }
-        this.i++;
-        this.pushToken(":");
-        return;
-      }
-      if (c === "?" && this.ch(1) !== "?" && this.ch(1) !== ".") {
-        let j = start + 1;
-        while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
-        if (this.src[j] === ":" && this.inDeclarePosition() && IDENT_PART.test(this.prevSignificantChar(start - 1))) {
-          const end = this.scanTypeExpression(j + 1, false);
-          this.erase(start, end);
-          this.i = end;
-          this.pushToken("erased");
-          return;
-        }
-        this.i++;
-        this.pushToken("?");
-        return;
-      }
-      if (c === "!" && this.ch(1) !== "=" && this.isPostfixBang(start)) {
-        this.erase(start, start + 1);
-        this.i++;
-        return;
-      }
-      if (c === "=" && this.ch(1) === ">") {
-        this.i += 2;
-        this.pushToken("=>");
-        return;
-      }
-      if (c === "<" && this.consumeLeadingGenerics(start)) return;
-      this.i++;
-      this.pushToken(c);
-    }
-    /** 空白跳跃（供声明结构找下一个非空白字符；不改游标，纯函数）。 */
-    skipWhitespaceFrom(index) {
-      if (index === null) return null;
-      let j = index;
-      while (j < this.src.length && /\s/.test(this.src[j])) j++;
-      return j;
-    }
-    /**
-     * 运算符位上的泛型参数列表（`const f = <T, >(x: T) => x`、`arr.map<T2>(...)` 之外的箭头形态）：
-     * 前一个显著字符不是值结尾（否则是 `a < b` 比较），且 `>` 之后紧跟 `(` 才擦。
-     */
-    consumeLeadingGenerics(at) {
-      if (!"([{,=;:>!&|?".includes(this.prevSignificantChar(at - 1))) return false;
-      const end = this.scanTypeParams(at);
-      if (end === null) return false;
-      const after = this.skipWhitespaceFrom(end);
-      if (after === null || this.src[after] !== "(") return false;
-      this.erase(at, end);
-      this.i = end;
-      return true;
-    }
-    /**
-     * `(` 是否为参数列表（声明位）：`function f(`、类体里的方法 `m(`、箭头 `=> (`，
-     * 以及出现在 `(` `,` `=` `>` `:` `[` `{` `}` `;` 之后（如 `map((v: T) => v)` 的内层括号）。
-     * 调用位 `foo(` 与控制流 `if (` `for (` 都不算。
-     * 误判成声明位也不足以擦掉什么：`:` 还要过 `isAnnotationColon` 的「名字前驱必须是
-     * `(` `,` `{` `;` 修饰符」这一关，而三元表达式的中间段前面必然是 `?`。
-     */
-    isDeclareParen(at) {
-      if (this.afterFunctionKeyword) return true;
-      if (this.tokenAt(2) === "function" && IDENT_START.test(this.tokenAt(1))) return true;
-      if (this.afterArrow) return true;
-      if (this.inClassBody() && IDENT_PART.test(this.prevSignificantChar(at - 1))) return true;
-      const prev = this.prevSignificantChar(at - 1);
-      return prev === "" || "(,=>:[{};".includes(prev);
-    }
-    /** `:` 是类型标注吗：看名字前驱 token 与所在帧（对象键、三元、`case` 一律排除）。 */
-    isAnnotationColon(at) {
-      const prev = this.prevSignificantChar(at - 1);
-      if (prev === ")") return this.justClosedDeclareParen;
-      if (prev === "}" || prev === "]") {
-        const frame = this.frames[this.frames.length - 1];
-        return frame?.kind === "paren" && frame.declare;
-      }
-      if (!IDENT_PART.test(prev)) return false;
-      if (this.tokenAt(1) === "number" || this.tokenAt(1) === "string") return false;
-      if (this.inDeclarePosition() && isAnnotationLeader(this.tokenAt(2))) return true;
-      return DECL_KEYWORDS.has(this.tokenAt(2));
-    }
-    /** 非空断言 `x!`：前一个显著字符是值结尾，且后一个非空白字符不是操作数起始。 */
-    isPostfixBang(at) {
-      const prev = this.prevSignificantChar(at - 1);
-      if (!(IDENT_PART.test(prev) || prev === ")" || prev === "]")) return false;
-      let j = at + 1;
-      while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
-      const next = this.src[j] ?? "";
-      if (next === "") return true;
-      return !(IDENT_START.test(next) || /[0-9]/.test(next) || "(![~".includes(next));
-    }
-    /* ———————————————— 区间扫描（全部字符串 / 注释安全） ———————————————— */
-    /** 跳过「名字 + 泛型参数」；没有合法名字时返回 null（`{ type: 1 }` 因此落空）。 */
-    skipNameAndParams(from) {
-      let j = from;
-      while (j < this.src.length && /\s/.test(this.src[j])) j++;
-      const nameStart = j;
-      while (j < this.src.length && IDENT_PART.test(this.src[j])) j++;
-      if (j === nameStart) return null;
-      const generic = this.scanTypeParams(j);
-      return generic === null ? j : generic;
-    }
-    /** `<T, U extends X>`：返回 `>` 之后的下标；跨到 `)` `]` `;` 换行前配不平则 null。 */
-    scanTypeParams(from) {
-      if (this.src[from] !== "<") return null;
-      let depth = 0;
-      let j = from;
-      for (; j < this.src.length; j++) {
-        const c = this.src[j];
-        if (c === "<") depth++;
-        else if (c === ">") {
-          depth--;
-          if (depth === 0) return j + 1;
-        } else if (c === ")" || c === "]" || c === ";" || c === "\n") return null;
-        else if (c === "'" || c === '"') j = this.scanQuoted(j) - 1;
-        else if (c === "`") j = this.scanTemplate(j) - 1;
-      }
-      return null;
-    }
-    /**
-     * 消费「刚读出的标识符之后」的泛型实参 / 类型参数（`function f<T>(`、方法 `m<T>(`、`f<T>(x)`）。
-     * 只有 `>` 之后紧跟 `(` / `{` / `implements` 才算——`if (a < b) {` 里 `>` 之后是 `)`，故安全。
-     */
-    consumeGenericsAfterName() {
-      if (this.ch() !== "<") return;
-      const end = this.scanTypeParams(this.i);
-      if (end === null) return;
-      let j = end;
-      while (j < this.src.length && (this.src[j] === " " || this.src[j] === "	")) j++;
-      const after = this.src.slice(j);
-      if (!/^[({]/.test(after) && !/^implements\b/.test(after)) return;
-      this.erase(this.i, end);
-      this.i = end;
-    }
-    /** 括号配平：返回闭括号之后的下标（未配平则到文件尾）。 */
-    scanBalanced(from, open, close) {
-      let depth = 0;
-      let j = from;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "'" || c === '"') j = this.scanQuoted(j);
-        else if (c === "`") j = this.scanTemplate(j);
-        else if (c === "/" && (this.src[j + 1] === "/" || this.src[j + 1] === "*"))
-          j = this.skipComment(j);
-        else if (c === open) {
-          depth++;
-          j++;
-        } else if (c === close) {
-          depth--;
-          j++;
-          if (depth === 0) return j;
-        } else j++;
-      }
-      return this.src.length;
-    }
-    skipComment(from) {
-      if (this.src[from + 1] === "/") {
-        const end2 = this.src.indexOf("\n", from);
-        return end2 === -1 ? this.src.length : end2;
-      }
-      const end = this.src.indexOf("*/", from + 2);
-      return end === -1 ? this.src.length : end + 2;
-    }
-    /** 语句结束（`;` 或括号已配平时的行尾），用于 `import type …`。 */
-    scanStatementEnd(from) {
-      let depth = 0;
-      let j = from;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "'" || c === '"') j = this.scanQuoted(j);
-        else if (c === "`") j = this.scanTemplate(j);
-        else if (c === "{" || c === "(" || c === "[") {
-          depth++;
-          j++;
-        } else if (c === "}" || c === ")" || c === "]") {
-          depth--;
-          j++;
-        } else if (c === ";" || c === "\n" && depth <= 0) break;
-        else j++;
-      }
-      return j;
-    }
-    /**
-     * 类型表达式结束下标：消费标识符 / 字符串字面量类型 / 泛型实参 / 元组 / 对象类型 /
-     * 函数类型（含 `=>` 返回值）/ 联合与交叉；在深度 0 的 `= , ; ) ]` 与「已结束的行」处停下。
-     *
-     * 两处歧义的处理：
-     * - `function f(): { a: number } { … }`——还没消费过类型原子时遇到的 `{` 属于类型，
-     *   之后再遇 `{` 才是函数体；`type X = A` 的初始值花括号整体算类型（`leadingBraceIsType`）。
-     * - `const x: Foo = { … }`——在 `=` 处停，不会把右侧对象字面量吞掉。
-     */
-    scanTypeExpression(from, leadingBraceIsType, topLevelArrowEnds = false) {
-      let depth = 0;
-      let j = from;
-      let sawAtom = false;
-      while (j < this.src.length) {
-        const c = this.src[j];
-        if (c === "'" || c === '"') {
-          j = this.scanQuoted(j);
-          sawAtom = true;
-        } else if (c === "`") {
-          j = this.scanTemplate(j);
-          sawAtom = true;
-        } else if (c === "/" && (this.src[j + 1] === "/" || this.src[j + 1] === "*")) {
-          j = this.skipComment(j);
-        } else if (c === "(" || c === "[") {
-          depth++;
-          sawAtom = true;
-          j++;
-        } else if (c === ")" || c === "]") {
-          if (depth === 0) break;
-          depth--;
-          j++;
-        } else if (c === "{") {
-          if (depth === 0 && sawAtom && !leadingBraceIsType) break;
-          j = this.scanBalanced(j, "{", "}");
-          sawAtom = true;
-        } else if (c === "}") {
-          if (depth === 0) break;
-          depth--;
-          j++;
-        } else if (depth === 0 && (c === "," || c === ";")) break;
-        else if (depth === 0 && c === "=") {
-          if (this.src[j + 1] === ">" && !topLevelArrowEnds) {
-            j += 2;
-            continue;
-          }
-          break;
-        } else if (depth === 0 && c === "\n") {
-          if (!this.typeContinuesAt(j)) break;
-          j++;
-        } else if (c === "<") {
-          const generic = this.scanTypeParams(j);
-          if (generic === null) break;
-          j = generic;
-          sawAtom = true;
-        } else {
-          if (IDENT_PART.test(c)) sawAtom = true;
-          j++;
-        }
-      }
-      return j;
-    }
-    /**
-     * 行尾处类型是否仍在继续：`type Id = string\n  | number` 要接得上，
-     * 而 `const x: Foo\nconst y = 1` 必须停。判据是两侧的非空邻字——
-     * 前一个是连接符（`| & < > = , . ? : (`）或后一个是连接符 / 闭合符（`| & , . ? : ) ] } >`）。
-     */
-    typeContinuesAt(index) {
-      for (let j = index - 1; j >= 0; j--) {
-        const c = this.src[j];
-        if (/\s/.test(c)) continue;
-        if ("|&<>=,.?:(".includes(c)) return true;
-        break;
-      }
-      for (let j = index + 1; j < this.src.length; j++) {
-        const c = this.src[j];
-        if (/\s/.test(c)) continue;
-        return "|&,.?:)]}>".includes(c);
-      }
-      return false;
-    }
-  };
-  function stripTypes(source) {
-    return new Eraser(source).run();
-  }
+  // src/test-runner.ts
+  init_strip_types();
 
   // src/test-framework.ts
   var TestAssertionError = class extends Error {
@@ -2503,6 +3608,17 @@ self.onmessage = async (event) => {
   }
 
   // src/container.ts
+  function viteBanner(server, fresh) {
+    return [
+      fresh ? `  VITE \u6D4F\u89C8\u5668\u5185 dev server \u5DF2\u5C31\u7EEA\uFF08root: ${server.root}\uFF09
+` : `  vite dev server \u5DF2\u5728\u8FD0\u884C\uFF08root: ${server.root}\uFF09
+`,
+      "\n",
+      "  \u279C  Local:   http://localhost:5173/\n",
+      "  \u279C  \u9884\u89C8\uFF1A\u7EC8\u7AEF / IDE \u7684\u9884\u89C8\u9762\u677F\u5DF2\u5C31\u7EEA\uFF0C\u7F16\u8F91\u4FDD\u5B58\u540E\u81EA\u52A8\u5237\u65B0\uFF08HMR\uFF09\n",
+      "  \u279C  \u505C\u6B62\uFF1Avite stop\uFF08\u6362\u76EE\u5F55\uFF1Avite <dir>\uFF09\n"
+    ].join("");
+  }
   function bootstrap(options) {
     const vfs = options.vfs ?? new VirtualFileSystem();
     if (options.initialTree !== void 0) vfs.mount(options.initialTree);
@@ -2521,12 +3637,46 @@ self.onmessage = async (event) => {
         return { code: outcome.code, stdout: outcome.stdout, stderr: outcome.stderr };
       }
     };
+    const net = options.net ?? createRelayFetch({
+      baseUrl: options.httpRelayBaseUrl ?? "/api/v1/http-relay",
+      ...options.fetchImpl === void 0 ? {} : { fetchImpl: options.fetchImpl }
+    });
+    let viteServer = null;
+    const vite = {
+      async start(args) {
+        const target = args[0] ?? "/";
+        const root = target.startsWith("/") ? normalize(target) : join(cwd, target);
+        if (viteServer !== null && viteServer.root === root)
+          return { code: 0, stdout: viteBanner(viteServer, false) };
+        await viteServer?.stop();
+        viteServer = null;
+        const { createViteServer: createViteServer2 } = await Promise.resolve().then(() => (init_vite_dev(), vite_dev_exports));
+        const server = createViteServer2(vfs, {
+          root,
+          ...options.viteCompiler === void 0 ? {} : { sfcCompiler: options.viteCompiler }
+        });
+        await server.ready;
+        viteServer = server;
+        emit("serverready", { port: server.port, url: server.url, kind: "vite", root: server.root });
+        return { code: 0, stdout: viteBanner(server, true) };
+      },
+      async stop() {
+        if (viteServer === null) return { code: 0, stdout: "vite: dev server \u672A\u5728\u8FD0\u884C\n" };
+        const root = viteServer.root;
+        await viteServer.stop();
+        viteServer = null;
+        return { code: 0, stdout: `  vite dev server \u5DF2\u505C\u6B62\uFF08root: ${root}\uFF09
+` };
+      }
+    };
     const shell = new Shell({
       vfs,
       getCwd: () => cwd,
       setCwd,
       ...runtime === void 0 ? {} : { runtime },
-      test
+      test,
+      net,
+      vite
     });
     const npmClient = createNpmClient({
       baseUrl: options.npmRelayBaseUrl,
@@ -2646,9 +3796,9 @@ self.onmessage = async (event) => {
       },
       async preview(previewOptions) {
         if (preview === null) {
-          const { createPreviewServer: createPreviewServer2 } = await Promise.resolve().then(() => (init_preview(), preview_exports));
+          const { createPreviewServer: createPreviewServer2 } = await Promise.resolve().then(() => (init_preview_server(), preview_server_exports));
           preview = createPreviewServer2(vfs, previewOptions);
-          emit("serverready", { port: preview.port, url: preview.url });
+          emit("serverready", { port: preview.port, url: preview.url, kind: "preview" });
         }
         return { url: preview.url, port: preview.port };
       },
@@ -2657,11 +3807,15 @@ self.onmessage = async (event) => {
         defaultRuntime?.close?.();
         await preview?.stop();
         preview = null;
+        await viteServer?.stop();
+        viteServer = null;
       }
     };
   }
 
   // src/index.ts
+  init_node_resolve();
+  init_vite_dev();
   init_path();
 
   // src/persistence.ts
@@ -2877,6 +4031,9 @@ self.onmessage = async (event) => {
     };
   }
 
+  // src/index.ts
+  init_strip_types();
+
   // src/offline/net.ts
   var HEALTH_CHECK_INTERVAL_MS = 3e4;
   var HEALTH_CHECK_TIMEOUT_MS = 5e3;
@@ -3140,7 +4297,6 @@ self.onmessage = async (event) => {
 
   // src/offline/workspace.ts
   var DB_NAME = "adep-offline-workspace";
-  var DB_VERSION = 1;
   function requestError(request) {
     return request.error ?? new Error("IndexedDB operation failed");
   }
@@ -3155,7 +4311,7 @@ self.onmessage = async (event) => {
           reject(new Error("IndexedDB not available"));
           return;
         }
-        const request = indexedDB.open(DB_NAME, DB_VERSION);
+        const request = indexedDB.open(DB_NAME);
         request.onupgradeneeded = () => {
         };
         request.onsuccess = () => {
@@ -3182,10 +4338,12 @@ self.onmessage = async (event) => {
           };
           request.onsuccess = () => {
             this.db = request.result;
+            this.initPromise = Promise.resolve(request.result);
             const tx2 = this.db.transaction(storeName, "readwrite");
             resolve(tx2.objectStore(storeName));
           };
           request.onerror = () => reject(requestError(request));
+          request.onblocked = () => reject(new Error("IndexedDB \u5347\u7EA7\u88AB\u5176\u4ED6\u6807\u7B7E\u9875\u963B\u585E\uFF08adep-offline-workspace\uFF09"));
         });
       }
       const tx = db.transaction(storeName, "readwrite");
@@ -5467,6 +6625,7 @@ self.onmessage = async (event) => {
   }
 
   // src/sim/runner.ts
+  init_strip_types();
   function safeStringify2(value) {
     if (typeof value === "string") return value;
     try {
@@ -5642,5 +6801,8 @@ self.onmessage = async (event) => {
       dispose: async () => void 0
     };
   }
+
+  // src/index.ts
+  init_function_fetch_proxy();
   return __toCommonJS(index_exports);
 })();