@adep/web-container 0.1.1 → 0.2.0

package/dist/index.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// packages/web-container/src/path.ts
+// src/path.ts
 var path_exports = {};
 __export(path_exports, {
   SEP: () => SEP,
@@ -73,15 +73,802 @@ function isValidSegment(name) {
 }
 var SEP;
 var init_path = __esm({
-  "packages/web-container/src/path.ts"() {
+  "src/path.ts"() {
     "use strict";
     SEP = "/";
   }
 });
 
-// packages/web-container/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
@@ -177,15 +964,658 @@ function createPreviewServer(vfs, options = {}) {
   };
 }
 var EXTERNAL_SRC;
-var init_preview = __esm({
-  "packages/web-container/src/preview.ts"() {
+var init_preview_server = __esm({
+  "src/preview-server.ts"() {
     "use strict";
     init_path();
     EXTERNAL_SRC = /(?:^https?:)?\/\//i;
   }
 });
 
-// packages/web-container/src/vfs.ts
+// 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/vfs.ts
 init_path();
 var ensureAbs = (path) => path.startsWith("/") ? normalize(path) : `/${normalize(path).replace(/^\/+/, "")}`;
 var ROOT = "/";
@@ -395,10 +1825,13 @@ var VirtualFileSystem = class {
   }
 };
 
-// packages/web-container/src/shell.ts
+// src/container.ts
+init_path();
+
+// src/shell.ts
 init_path();
 
-// packages/web-container/src/completion.ts
+// src/completion.ts
 init_path();
 var SHELL_COMMANDS = [
   "pwd",
@@ -414,9 +1847,12 @@ var SHELL_COMMANDS = [
   "cd",
   "head",
   "tail",
+  "curl",
+  "wget",
   "test",
   "node",
   "js",
+  "vite",
   "help"
 ];
 var EXTRA_COMMANDS = ["npm"];
@@ -507,7 +1943,7 @@ function helpText() {
 `;
 }
 
-// packages/web-container/src/shell.ts
+// src/shell.ts
 function tokenize(line) {
   const tokens = [];
   let current = "";
@@ -721,6 +2157,33 @@ var Shell = class {
         }
         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
 `;
@@ -743,6 +2206,168 @@ var Shell = class {
     }
     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 不该让终端报错），由调用方决定「不响应」还是「列出可能项」。
@@ -756,261 +2381,290 @@ var Shell = class {
     return join(this.ctx.getCwd(), target);
   }
 };
-
-// packages/web-container/src/tar.ts
-var BLOCK = 512;
-var GZIP_MAGIC_0 = 31;
-var GZIP_MAGIC_1 = 139;
-function readString(bytes, start, length) {
-  let end = start;
-  while (end < start + length && bytes[end] !== 0) end++;
-  return new TextDecoder("ascii").decode(bytes.subarray(start, end)).replace(/\0+$/g, "").trim();
-}
-function parseOctalSize(bytes, start, length) {
-  const raw = bytes.subarray(start, start + length);
-  if ((raw[0] & 128) !== 0) {
-    let value = 0;
-    for (const byte of raw.subarray(1)) value = value * 256 + byte;
-    return value;
-  }
-  const text = readString(bytes, start, length);
-  if (text === "") return 0;
-  if (!/^[0-7]+$/.test(text)) throw new Error(`tar \u5934\u90E8 size \u5B57\u6BB5\u975E\u6CD5\uFF1A"${text}"`);
-  return Number.parseInt(text, 8);
-}
-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}"`);
+var NetCommandError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "NetCommandError";
   }
-}
-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");
+};
+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) };
   }
-  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
-  const buffer = await new Response(stream).arrayBuffer();
-  return new Uint8Array(buffer);
+  return { matched: false, value: null };
 }
-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();
+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;
     }
-    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}"`
-      );
+    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;
+      }
     }
-    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;
 }
-
-// packages/web-container/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`);
+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;
     }
-    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`
-      );
+    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;
     }
-    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`);
+    m = matchValueFlag(arg, "-A", ["--user-agent"], consume);
+    if (m.matched) {
+      flags.headers["user-agent"] = m.value ?? "";
+      continue;
     }
-    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`
-        );
-      }
+    m = matchValueFlag(arg, "-u", ["--user"], consume);
+    if (m.matched) {
+      flags.headers["authorization"] = `Basic ${btoa(m.value ?? "")}`;
+      continue;
     }
-    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`
+    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;
   }
-  if (meta.main !== void 0) {
-    if (typeof meta.main !== "string") {
-      throw new ResolveError(`${context}\uFF1Amain \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  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;
     }
-    return withinPackage(pkgDirAbs, meta.main, context);
+    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 join(pkgDirAbs, "index.js");
+  return flags;
 }
-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) };
+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;
   }
-  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;
+
+// src/tar.ts
+var BLOCK = 512;
+var GZIP_MAGIC_0 = 31;
+var GZIP_MAGIC_1 = 139;
+function readString(bytes, start, length) {
+  let end = start;
+  while (end < start + length && bytes[end] !== 0) end++;
+  return new TextDecoder("ascii").decode(bytes.subarray(start, end)).replace(/\0+$/g, "").trim();
+}
+function parseOctalSize(bytes, start, length) {
+  const raw = bytes.subarray(start, start + length);
+  if ((raw[0] & 128) !== 0) {
+    let value = 0;
+    for (const byte of raw.subarray(1)) value = value * 256 + byte;
+    return value;
   }
-  return null;
+  const text = readString(bytes, start, length);
+  if (text === "") return 0;
+  if (!/^[0-7]+$/.test(text)) throw new Error(`tar \u5934\u90E8 size \u5B57\u6BB5\u975E\u6CD5\uFF1A"${text}"`);
+  return Number.parseInt(text, 8);
 }
-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;
+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}"`);
   }
-  return asFile(fs, join(dirAbs, "index"));
 }
-function fsIsDirectory(fs, path) {
-  const probe = fs;
-  return probe.isDirectory?.(path) ?? false;
+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 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;
 }
 
-// packages/web-container/src/npm-client.ts
+// 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) {
@@ -1161,7 +2815,58 @@ function createNpmClient(options) {
   };
 }
 
-// packages/web-container/src/module-loader.ts
+// 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;
@@ -1269,7 +2974,7 @@ function composeRequire(vfs, entryFileAbs, cache) {
   };
 }
 
-// packages/web-container/src/worker-runtime.ts
+// src/worker-runtime.ts
 async function evaluateSource(source, filename, args, extraGlobals) {
   const output = [];
   const fakeConsole = {
@@ -1367,616 +3072,10 @@ function createWorkerRuntime(vfs, options = {}) {
   };
 }
 
-// packages/web-container/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();
 
-// packages/web-container/src/test-framework.ts
+// src/test-framework.ts
 var TestAssertionError = class extends Error {
   constructor(message, expected, received) {
     super(message);
@@ -2239,7 +3338,7 @@ function stringify(value, seen) {
   return `{ ${entries.join(", ")} }`;
 }
 
-// packages/web-container/src/test-runner.ts
+// src/test-runner.ts
 var TEST_FILE_PATTERN = /\.(?:test|spec)\.[cm]?[jt]s$/;
 var IGNORED_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", ".adep"]);
 function createTestRunner(options) {
@@ -2408,7 +3507,18 @@ function exampleTestSource(name = "example") {
   ].join("\n");
 }
 
-// packages/web-container/src/container.ts
+// 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);
@@ -2427,12 +3537,46 @@ function bootstrap(options) {
       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,
@@ -2552,9 +3696,9 @@ function bootstrap(options) {
     },
     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 };
     },
@@ -2563,14 +3707,18 @@ function bootstrap(options) {
       defaultRuntime?.close?.();
       await preview?.stop();
       preview = null;
+      await viteServer?.stop();
+      viteServer = null;
     }
   };
 }
 
-// packages/web-container/src/index.ts
+// src/index.ts
+init_node_resolve();
+init_vite_dev();
 init_path();
 
-// packages/web-container/src/persistence.ts
+// src/persistence.ts
 function cloneEntries(entries) {
   return entries.map(
     (entry) => entry.kind === "file" ? { path: entry.path, kind: "file", contents: entry.contents ?? "" } : { path: entry.path, kind: "dir" }
@@ -2783,7 +3931,10 @@ function createCommandHistory(options) {
   };
 }
 
-// packages/web-container/src/offline/net.ts
+// src/index.ts
+init_strip_types();
+
+// src/offline/net.ts
 var HEALTH_CHECK_INTERVAL_MS = 3e4;
 var HEALTH_CHECK_TIMEOUT_MS = 5e3;
 var HEALTH_ENDPOINT = "/api/v1/health";
@@ -2903,7 +4054,7 @@ function onNetworkChange(listener) {
   return networkMonitor.subscribe(listener);
 }
 
-// packages/web-container/src/offline/queue.ts
+// src/offline/queue.ts
 var STORAGE_KEY = "adep:offline:publish-queue";
 function simpleHash(input) {
   let hash = 0;
@@ -3044,9 +4195,8 @@ var PublishQueue = class {
 };
 var publishQueue = new PublishQueue();
 
-// packages/web-container/src/offline/workspace.ts
+// 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");
 }
@@ -3061,7 +4211,7 @@ var IndexedDBBackend = class {
         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 = () => {
@@ -3088,10 +4238,12 @@ var IndexedDBBackend = class {
         };
         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");
@@ -3235,7 +4387,7 @@ var OfflineWorkspace = class {
 };
 var offlineWorkspace = new OfflineWorkspace();
 
-// packages/web-container/src/sim/kv.ts
+// src/sim/kv.ts
 function createMemorySimKv() {
   const map = /* @__PURE__ */ new Map();
   return {
@@ -3301,7 +4453,7 @@ function pickDefaultSimKv() {
   return typeof indexedDB !== "undefined" ? createIdbSimKv() : createMemorySimKv();
 }
 
-// packages/runtime/src/shared/capability-keys.ts
+// ../runtime/src/shared/capability-keys.ts
 var RPC_CAPABILITY_KEY = "__adepRpc";
 var CHAIN_CAPABILITY_KEY = "__adepChain";
 var DB_RPC = {
@@ -3333,7 +4485,7 @@ var REALTIME_CAPABILITY_METHODS = [
   "unsubscribe"
 ];
 
-// packages/runtime/src/database/builder/dialect.ts
+// ../runtime/src/database/builder/dialect.ts
 var sqliteDialect = {
   name: "sqlite",
   placeholder: () => "?",
@@ -3352,7 +4504,7 @@ function dialectFor(driver) {
   return driver.engine === "pg" ? postgresDialect : sqliteDialect;
 }
 
-// packages/runtime/src/database/provision/identifier.ts
+// ../runtime/src/database/provision/identifier.ts
 var DbError = class extends Error {
   constructor(status, code, message) {
     super(message);
@@ -3376,7 +4528,7 @@ function quoteIdentifier(name) {
   return `"${name.replace(/"/g, '""')}"`;
 }
 
-// packages/runtime/src/database/builder/guards.ts
+// ../runtime/src/database/builder/guards.ts
 function unsafeOperation(message) {
   return new DbError(400, "DB_UNSAFE_OP", message);
 }
@@ -3400,7 +4552,7 @@ function assertReadOnlyQuery(sql) {
   }
 }
 
-// packages/runtime/src/database/builder/owned.ts
+// ../runtime/src/database/builder/owned.ts
 var OWNED_PK = "id";
 var OWNED_OWNER_KEY = "__owner_key";
 var CHANGE_LOG_PREFIX = "_adep_changes_";
@@ -3513,7 +4665,7 @@ async function readChanges(driver, table, query = {}) {
   return rows.map(parseChange);
 }
 
-// packages/runtime/src/database/builder/ulid.ts
+// ../runtime/src/database/builder/ulid.ts
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var TIME_LEN = 10;
 var RANDOM_LEN = 16;
@@ -3579,7 +4731,7 @@ function ulid(now = Date.now()) {
   return time + random;
 }
 
-// packages/runtime/src/database/builder/table.ts
+// ../runtime/src/database/builder/table.ts
 var OPERATORS = /* @__PURE__ */ new Set([
   "=",
   "!=",
@@ -3898,7 +5050,7 @@ function createTableBuilder(table, driver, dialect, options = {}) {
   return build(initialState);
 }
 
-// packages/runtime/src/database/builder/index.ts
+// ../runtime/src/database/builder/index.ts
 var TX_STATES = /* @__PURE__ */ new WeakMap();
 function createCloudDb(driver, options = {}) {
   const dialect = options.dialect ?? dialectFor(driver);
@@ -3952,7 +5104,7 @@ function createCloudDb(driver, options = {}) {
   return makeHandle({ allowWriteDuringTx: false });
 }
 
-// packages/runtime/src/database/sdk/cloud.ts
+// ../runtime/src/database/sdk/cloud.ts
 var CLOUD_DB_SPEC = {
   kind: "cloud-db",
   rootMethod: "table",
@@ -4056,7 +5208,7 @@ function createDbCapability(driver, options = {}) {
   };
 }
 
-// packages/runtime/src/sim/sql-engine.ts
+// ../runtime/src/sim/sql-engine.ts
 var SimDbError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -4474,7 +5626,7 @@ function project(rows, selectRaw) {
   });
 }
 
-// packages/web-container/src/sim/db.ts
+// src/sim/db.ts
 function simDbKey(projectId) {
   return `db:${projectId}`;
 }
@@ -4502,7 +5654,7 @@ function createBrowserSimDb(options) {
   return { bundle, engine, driver };
 }
 
-// packages/runtime/src/storage/driver.ts
+// ../runtime/src/storage/driver.ts
 var PROJECT_QUOTA_BYTES = 1024 * 1024 * 1024;
 var StorageError = class extends Error {
   constructor(status, code, message) {
@@ -4543,7 +5695,7 @@ function assertSafeStoragePath(path) {
   return path;
 }
 
-// packages/runtime/src/storage/hmac-sha256.ts
+// ../runtime/src/storage/hmac-sha256.ts
 var K = new Uint32Array([
   1116352408,
   1899447441,
@@ -4704,7 +5856,7 @@ function hmacSha256Hex(key, message) {
   return [...hmacSha256(key, message)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-// packages/runtime/src/storage/signature.ts
+// ../runtime/src/storage/signature.ts
 var DEFAULT_SIGN_TTL_SECONDS = 15 * 60;
 var SIGN_EXPIRES_KEY = "x-expires";
 var SIGN_SIGNATURE_KEY = "x-signature";
@@ -4719,7 +5871,7 @@ function signDownloadUrl(config, projectId, path, ttlSeconds = DEFAULT_SIGN_TTL_
   return `${base}?${SIGN_EXPIRES_KEY}=${expires}&${SIGN_SIGNATURE_KEY}=${signature}`;
 }
 
-// packages/runtime/src/storage/cloud.ts
+// ../runtime/src/storage/cloud.ts
 var DEFAULT_VISIBILITY = "private";
 function asBytes(data) {
   if (typeof data === "string") return new TextEncoder().encode(data);
@@ -4778,7 +5930,7 @@ function createStorageCapability(driver, signer, projectId) {
   };
 }
 
-// packages/web-container/src/sim/storage.ts
+// src/sim/storage.ts
 function toMeta(object) {
   return {
     path: object.path,
@@ -4891,7 +6043,7 @@ function createBrowserSimStorage(options) {
   return { bundle, driver };
 }
 
-// packages/runtime/src/sim/realtime.ts
+// ../runtime/src/sim/realtime.ts
 var SimRealtime = class {
   seq = 0;
   subscribers = /* @__PURE__ */ new Map();
@@ -4933,7 +6085,7 @@ var SimRealtime = class {
 };
 var REALTIME_CODES = REALTIME_CAPABILITY_CODES;
 
-// packages/web-container/src/sim/realtime.ts
+// src/sim/realtime.ts
 function defaultTicketProvider(projectId) {
   return async () => {
     const res = await fetch("/api/v1/realtime/ticket", {
@@ -5103,7 +6255,7 @@ function createBrowserRealtime(options) {
   };
 }
 
-// packages/runtime/src/functions/runtime/chain.ts
+// ../runtime/src/functions/runtime/chain.ts
 function isChainCapability(value) {
   if (typeof value !== "object" || value === null) return false;
   const spec = value[CHAIN_CAPABILITY_KEY];
@@ -5174,7 +6326,7 @@ function createChainClient(capability, port, pending, nextId, spec) {
   return makeRoot(void 0);
 }
 
-// packages/runtime/src/functions/runtime/cloud-container.ts
+// ../runtime/src/functions/runtime/cloud-container.ts
 var KNOWN_CAPABILITY_HINTS = {
   db: {
     code: "DB_NOT_PROVISIONED",
@@ -5250,7 +6402,7 @@ function createCloudContainer() {
   };
 }
 
-// packages/web-container/src/sim/ctx.ts
+// src/sim/ctx.ts
 function createLocalPort(handler) {
   const listeners = [];
   const dispatch = (message) => {
@@ -5330,7 +6482,7 @@ function buildCloudFromBundle(bundle) {
   return container.cloud;
 }
 
-// packages/runtime/src/functions/runtime/exports.ts
+// ../runtime/src/functions/runtime/exports.ts
 function transformModule(code) {
   let out = code;
   const named = [];
@@ -5372,7 +6524,8 @@ function transformModule(code) {
   return out;
 }
 
-// packages/web-container/src/sim/runner.ts
+// src/sim/runner.ts
+init_strip_types();
 function safeStringify2(value) {
   if (typeof value === "string") return value;
   try {
@@ -5502,7 +6655,7 @@ function createOfflineFunctionRunner(options = {}) {
   return { run };
 }
 
-// packages/web-container/src/sim/runtime.ts
+// src/sim/runtime.ts
 function mergeBundles(bundles) {
   const capabilities = [];
   const byName = /* @__PURE__ */ new Map();
@@ -5548,10 +6701,14 @@ async function createBrowserSimRuntime(options) {
     dispose: async () => void 0
   };
 }
+
+// src/index.ts
+init_function_fetch_proxy();
 export {
   COMPLETABLE_COMMANDS,
   DEFAULT_MAX_INSTALL_DEPTH,
   EXTRA_COMMANDS,
+  FN_FETCH_INTERCEPTOR_SCRIPT,
   RESOLVE_EXTENSIONS,
   ResolveError,
   SHELL_COMMANDS,
@@ -5560,6 +6717,7 @@ export {
   TestAssertionError,
   UnsupportedTsSyntaxError,
   VirtualFileSystem,
+  ViteDevError,
   applyCompletion,
   bootstrap,
   buildCloudFromBundle,
@@ -5575,6 +6733,7 @@ export {
   createBrowserStorageDriver,
   createCommandHistory,
   createFsPersistence,
+  createFunctionFetchHandler,
   createIdbSimKv,
   createIndexedDbFsBackend,
   createLocalPort,
@@ -5583,10 +6742,12 @@ export {
   createMemorySimKv,
   createNpmClient,
   createOfflineFunctionRunner,
+  createRelayFetch,
   createRequire,
   createSandboxModuleGlobals,
   createTestRunner,
   createTestScope,
+  createViteServer,
   createWorkerRuntime,
   deepEqual,
   displayPath,
@@ -5615,6 +6776,7 @@ export {
   resolvePackageEntry,
   restoreVfs,
   runCollectedTests,
+  scanEsmSpecifiers,
   simDbKey,
   simStorageKey,
   snapshotVfs,