@adep/web-container 0.2.2 → 0.2.4

package/dist/web-container.iife.js

@@ -147,8 +147,17 @@ var AdepWebContainer = (() => {
       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["."];
+      const table = exp;
+      const dot = table["."];
+      const order = condition === "import" ? IMPORT_CONDITION_ORDER : REQUIRE_CONDITION_ORDER;
+      const resolveRel = (rel) => withinPackage(pkgDirAbs, rel, context);
       if (dot === void 0) {
+        const keys = Object.keys(table);
+        if (keys.length > 0 && keys.every((key) => !key.startsWith("."))) {
+          const shorthand = pickConditionTarget(table, order, resolveRel, context);
+          if (shorthand !== null) return shorthand;
+          throw new ResolveError(`${context}\uFF1A\u5305\u6839\u6761\u4EF6\u5BF9\u8C61\u91CC\u6CA1\u6709 ${order.join("/")} \u5165\u53E3`);
+        }
         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`
         );
@@ -159,8 +168,6 @@ var AdepWebContainer = (() => {
       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 order = condition === "import" ? IMPORT_CONDITION_ORDER : REQUIRE_CONDITION_ORDER;
-      const resolveRel = (rel) => withinPackage(pkgDirAbs, rel, context);
       const hit = pickConditionTarget(dot, order, resolveRel, context);
       if (hit !== null) return hit;
       throw new ResolveError(`${context}\uFF1Aexports["."] \u6761\u4EF6\u5BF9\u8C61\u91CC\u6CA1\u6709 ${order.join("/")} \u5165\u53E3`);
@@ -359,6 +366,28 @@ var AdepWebContainer = (() => {
           }
           return "";
         }
+        /**
+         * `interface` / `type` 声明之前若有 `export` 关键字，返回该关键字的起始下标，否则原样返回。
+         *
+         * 为什么必须吞掉：`export interface X { … }` 里 `interface` 分支只擦它自己那一段，
+         * 留下的孤立 `export` 是**非法 JS**——浏览器解析模块时直接
+         * `SyntaxError: Unexpected token 'export'`（实测 countdown 项目 `lib/auth.ts` 的
+         * `export interface AppUser`：整条预览链路因此白屏）。`export type X = …` 由 `export`
+         * 分支整条擦除，不受影响。
+         *
+         * 判据分两步：token 回看确认前一个显著 token 就是 `export`（避免误吞 `re-export` 之类
+         * 同名标识符——那会在下面按字符再校验一次）；位置则往前跳空白后左推 6 个字符，并要求
+         * 再前一个字符不是标识符字符（`xexport interface` 不吞）。
+         */
+        includeLeadingExport(start) {
+          if (this.tokenAt(2) !== "export") return start;
+          let end = start - 1;
+          while (end >= 0 && /\s/.test(this.src[end])) end--;
+          if (end < 5 || this.src.slice(end - 5, end + 1) !== "export") return start;
+          const before = this.src[end - 6];
+          if (before !== void 0 && IDENT_PART.test(before)) return start;
+          return end - 5;
+        }
         /** 擦除 `[from, to)`：填等长空格，换行照抄——擦完行号与原文件一致。 */
         erase(from, to) {
           for (let j = Math.max(from, 0); j < to; j++) this.chars[j] = this.src[j] === "\n" ? "\n" : " ";
@@ -498,19 +527,31 @@ var AdepWebContainer = (() => {
           }
           switch (word) {
             case "interface": {
-              const after = this.skipWhitespaceFrom(this.skipNameAndParams(start + word.length));
+              const heritage = this.skipInterfaceExtends(this.skipNameAndParams(start + word.length));
+              const after = heritage === null ? null : this.skipWhitespaceFrom(heritage);
               if (after === null || this.src[after] !== "{") return;
               const end = this.scanBalanced(after, "{", "}");
-              this.erase(start, end);
+              this.erase(this.includeLeadingExport(start), end);
               this.i = end;
               this.pushToken("erased");
               return;
             }
             case "type": {
+              if (this.frames[this.frames.length - 1]?.specifierList === true) {
+                const specifierEnd = this.scanTypeOnlySpecifier(this.i);
+                if (specifierEnd !== null) {
+                  this.erase(start, specifierEnd);
+                  this.i = specifierEnd;
+                } else {
+                  this.erase(start, start + word.length);
+                }
+                this.pushToken("erased");
+                return;
+              }
               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.erase(this.includeLeadingExport(start), end);
               this.i = end;
               this.pushToken("erased");
               return;
@@ -537,16 +578,20 @@ var AdepWebContainer = (() => {
               this.pushToken("erased");
               return;
             }
-            case "class":
-              this.pendingClassBody = true;
+            case "class": {
+              const next = this.skipWhitespaceFrom(this.i);
+              if (next !== null && (this.src[next] === "{" || IDENT_START.test(this.src[next]))) {
+                this.pendingClassBody = true;
+              }
               return;
+            }
             case "as":
             case "satisfies": {
               if (this.frames[this.frames.length - 1]?.specifierList === true) return;
               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);
+              const end = this.scanTypeExpression(this.i, true);
               this.erase(start, end);
               this.i = end;
               return;
@@ -682,6 +727,62 @@ var AdepWebContainer = (() => {
           this.i = end;
           return true;
         }
+        /**
+         * `interface X extends A, B<T> {` 的继承子句：返回接口体 `{` 的下标。
+         *
+         * 不处理 `extends` 会让 `interface` 分支取不到 `{` 而**整条不擦**——`export interface
+         * DecodedEvent extends CountdownEvent { … }` 原样留在产物里，浏览器解析即
+         * `SyntaxError: Unexpected token 'export'`（实测 countdown 的 lib/date.ts；同项目两个
+         * `.vue` 产物是它的级联失败）。无 `extends` 时原样返回入参（等价旧行为）；遇到字符串 /
+         * 配不平的泛型一律返回 null（判不准就不擦）。
+         */
+        skipInterfaceExtends(from) {
+          if (from === null) return null;
+          const j = this.skipWhitespaceFrom(from);
+          if (j === null || !this.src.startsWith("extends", j) || IDENT_PART.test(this.src[j + 7] ?? "")) {
+            return j;
+          }
+          let k = this.skipWhitespaceFrom(j + 7);
+          while (k !== null) {
+            const c = this.src[k];
+            if (c === "{" || c === ";") return k;
+            if (c === "<") {
+              const end = this.scanTypeParams(k);
+              if (end === null) return null;
+              k = end;
+              continue;
+            }
+            if (c === "'" || c === '"' || c === "`") return null;
+            k = this.skipWhitespaceFrom(k + 1);
+          }
+          return null;
+        }
+        /**
+         * 「仅类型说明符」`type X [as Y]` 的擦除终点（返回应擦到、不含的下标）。
+         *
+         * - `type` 之后不是标识符 → null（调用方退化为只擦关键字，不猜）；
+         * - 连带**其后的**逗号一起擦（`{ type A, b }` → `{   b }`）；末位说明符没有逗号，
+         *   留下的 `{ a, }` 是合法尾逗号，无需回首删前导逗号；
+         * - `as Y` 重命名一并擦除（只影响类型侧，运行时无绑定）。
+         */
+        scanTypeOnlySpecifier(from) {
+          let j = this.skipWhitespaceFrom(from);
+          if (j === null || !IDENT_START.test(this.src[j])) return null;
+          j++;
+          while (j < this.src.length && IDENT_PART.test(this.src[j])) j++;
+          const asAt = this.skipWhitespaceFrom(j);
+          if (asAt !== null && this.src.startsWith("as", asAt) && !IDENT_PART.test(this.src[asAt + 2] ?? "")) {
+            const nameAt = this.skipWhitespaceFrom(asAt + 2);
+            if (nameAt !== null && IDENT_START.test(this.src[nameAt])) {
+              let k = nameAt + 1;
+              while (k < this.src.length && IDENT_PART.test(this.src[k])) k++;
+              j = k;
+            }
+          }
+          const next = this.skipWhitespaceFrom(j);
+          if (next !== null && this.src[next] === ",") return next + 1;
+          return j;
+        }
         /**
          * `{` 是 import / export 的说明符列表吗——`{ a as b }` 覆盖 `import { … }`、
          * `export { … }` 与 `import def, { … }` 三种写法（后者说明符花括号的前驱 token 是 `,`）。
@@ -692,8 +793,8 @@ var AdepWebContainer = (() => {
           return back1 === "," && this.tokenAt(3) === "import";
         }
         /**
-         * `(` 是否为参数列表（声明位）：`function f(`、类体里的方法 `m(`、箭头 `=> (`，
-         * 以及出现在 `(` `,` `=` `>` `:` `[` `{` `}` `;` 之后（如 `map((v: T) => v)` 的内层括号）。
+         * `(` 是否为参数列表（声明位）：`function f(`、`async` 箭头 `async (`、类体里的方法 `m(`、
+         * 箭头 `=> (`，以及出现在 `(` `,` `=` `>` `:` `[` `{` `}` `;` 之后（如 `map((v: T) => v)` 的内层括号）。
          * 调用位 `foo(` 与控制流 `if (` `for (` 都不算。
          * 误判成声明位也不足以擦掉什么：`:` 还要过 `isAnnotationColon` 的「名字前驱必须是
          * `(` `,` `{` `;` 修饰符」这一关，而三元表达式的中间段前面必然是 `?`。
@@ -702,6 +803,7 @@ var AdepWebContainer = (() => {
           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.tokenAt(1) === "async") return true;
           if (this.tokenAt(1) === "return") return true;
           if (this.inClassBody() && IDENT_PART.test(this.prevSignificantChar(at - 1))) return true;
           const prev = this.prevSignificantChar(at - 1);
@@ -741,7 +843,7 @@ var AdepWebContainer = (() => {
           const generic = this.scanTypeParams(j);
           return generic === null ? j : generic;
         }
-        /** `<T, U extends X>`：返回 `>` 之后的下标；跨到 `)` `]` `;` 换行前配不平则 null。 */
+        /** `<T, U extends X>`：返回 `>` 之后的下标；尖括号内任何非 `<`/`>` 字符（含 `]` `;` `\n` `)`）都是合法类型字符，配不平自然到文件尾返回 null。 */
         scanTypeParams(from) {
           if (this.src[from] !== "<") return null;
           let depth = 0;
@@ -752,8 +854,7 @@ var AdepWebContainer = (() => {
             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 === "'" || c === '"') j = this.scanQuoted(j) - 1;
             else if (c === "`") j = this.scanTemplate(j) - 1;
           }
           return null;
@@ -885,13 +986,14 @@ var AdepWebContainer = (() => {
         /**
          * 行尾处类型是否仍在继续：`type Id = string\n  | number` 要接得上，
          * 而 `const x: Foo\nconst y = 1` 必须停。判据是两侧的非空邻字——
-         * 前一个是连接符（`| & < > = , . ? : (`）或后一个是连接符 / 闭合符（`| & , . ? : ) ] } >`）。
+         * 前一个是连接符（`| & < = , . ? : (`，不含 `>`——`Foo<T>` 后换行是语句边界，
+         * 含 `>` 会把下一行的 `try` 等吞进类型区间）或后一个是连接符 / 闭合符（`| & , . ? : ) ] } >`）。
          */
         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;
+            if ("|&<=,.?:(".includes(c)) return true;
             break;
           }
           for (let j = index + 1; j < this.src.length; j++) {
@@ -905,6 +1007,206 @@ var AdepWebContainer = (() => {
     }
   });
 
+  // src/css-imports.ts
+  function isLocalSpec(spec) {
+    return spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/");
+  }
+  function skipString(css, start) {
+    const quote = css[start];
+    let i = start + 1;
+    while (i < css.length) {
+      if (css[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (css[i] === quote) return i + 1;
+      i++;
+    }
+    return css.length;
+  }
+  function matchParen(text, open) {
+    let depth = 0;
+    let i = open;
+    while (i < text.length) {
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        i = skipString(text, i);
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) return i;
+      }
+      i++;
+    }
+    return text.length;
+  }
+  function parseSpecifier(css, from) {
+    let i = from;
+    while (i < css.length && /\s/.test(css[i])) i++;
+    const urlHead = /^url\s*\(/i.exec(css.slice(i, i + 8));
+    if (urlHead !== null) {
+      const open = i + urlHead[0].length - 1;
+      const close = matchParen(css, open);
+      if (close >= css.length) return { spec: null, next: i };
+      const inner = css.slice(open + 1, close).trim();
+      const quoted = inner.startsWith('"') || inner.startsWith("'");
+      return { spec: quoted ? inner.slice(1, -1).trim() : inner, next: close + 1 };
+    }
+    const quote = css[i];
+    if (quote === '"' || quote === "'") {
+      const end = skipString(css, i);
+      if (css[end - 1] !== quote) return { spec: null, next: i };
+      return { spec: css.slice(i + 1, end - 1), next: end };
+    }
+    return { spec: null, next: i };
+  }
+  function parseImport(css, start) {
+    const parsed = parseSpecifier(css, start + IMPORT_KEYWORD.length);
+    if (parsed.spec === null) return null;
+    let j = parsed.next;
+    let depth = 0;
+    while (j < css.length) {
+      const ch = css[j];
+      if (ch === '"' || ch === "'") {
+        j = skipString(css, j);
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+      else if (ch === ";" && depth <= 0) break;
+      else if (ch === "{" || ch === "}") return null;
+      j++;
+    }
+    if (j >= css.length) return null;
+    return {
+      start,
+      end: j + 1,
+      spec: parsed.spec,
+      conditions: css.slice(parsed.next, j).trim(),
+      raw: css.slice(start, j + 1)
+    };
+  }
+  function scanCssImports(css) {
+    const hits = [];
+    let i = 0;
+    while (i < css.length) {
+      const ch = css[i];
+      if (ch === "/" && css[i + 1] === "*") {
+        const close = css.indexOf("*/", i + 2);
+        i = close === -1 ? css.length : close + 2;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        i = skipString(css, i);
+        continue;
+      }
+      if (ch === "@" && /^@import(?![-\w])/i.test(css.slice(i, i + IMPORT_KEYWORD.length + 1))) {
+        const hit = parseImport(css, i);
+        if (hit !== null) {
+          hits.push(hit);
+          i = hit.end;
+          continue;
+        }
+      }
+      i++;
+    }
+    return hits;
+  }
+  function stripCharset(css) {
+    return css.replace(/^\uFEFF/, "").replace(/^\s*@charset\s+(["'])[^"']*\1\s*;/i, "");
+  }
+  function splitImportConditions(conditions) {
+    let rest = conditions.trim();
+    let layer = null;
+    const layerFn = /^layer\s*\(/i.exec(rest);
+    if (layerFn !== null) {
+      const open = layerFn[0].length - 1;
+      const close = matchParen(rest, open);
+      layer = rest.slice(open + 1, close).trim();
+      rest = rest.slice(close + 1).trim();
+    } else if (/^layer(?![-\w(])/i.test(rest)) {
+      layer = "";
+      rest = rest.slice("layer".length).trim();
+    }
+    let supports = "";
+    const supportsFn = /^supports\s*\(/i.exec(rest);
+    if (supportsFn !== null) {
+      const open = supportsFn[0].length - 1;
+      const close = matchParen(rest, open);
+      supports = rest.slice(open + 1, close).trim();
+      rest = rest.slice(close + 1).trim();
+    }
+    return { layer, supports, media: rest };
+  }
+  function applyImportConditions(css, conditions) {
+    if (conditions === "") return css;
+    const { layer, supports, media } = splitImportConditions(conditions);
+    let out = css;
+    if (supports !== "") out = `@supports ${supports} {
+${out}
+}`;
+    if (layer !== null) out = layer === "" ? `@layer {
+${out}
+}` : `@layer ${layer} {
+${out}
+}`;
+    if (media !== "") out = `@media ${media} {
+${out}
+}`;
+    return out;
+  }
+  function expand(css, importerAbs, resolver, seen) {
+    const hits = scanCssImports(css);
+    if (hits.length === 0) return css;
+    const parts = [];
+    let cursor = 0;
+    for (const hit of hits) {
+      parts.push(css.slice(cursor, hit.start));
+      parts.push(expandHit(hit, importerAbs, resolver, seen));
+      cursor = hit.end;
+    }
+    parts.push(css.slice(cursor));
+    return parts.join("");
+  }
+  function expandHit(hit, importerAbs, resolver, seen) {
+    if (hit.spec === null) return hit.raw;
+    const spec = hit.spec.trim();
+    if (spec === "" || EXTERNAL_SPEC.test(spec)) return hit.raw;
+    const abs = resolver.resolve(spec, importerAbs);
+    if (abs === null) {
+      if (isLocalSpec(spec))
+        throw new CssImportError(
+          `CSS @import \u627E\u4E0D\u5230\u6587\u4EF6 "${spec}"\uFF08\u5728 ${importerAbs} \u4E2D\uFF09\u2014\u2014\u76F8\u5BF9\u8DEF\u5F84\u6309\u8BE5\u6587\u4EF6\u7684\u6240\u5728\u76EE\u5F55\u89E3\u6790\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E\u3002`
+        );
+      return hit.raw;
+    }
+    if (!abs.toLowerCase().endsWith(".css")) return hit.raw;
+    if (seen.has(abs)) return "";
+    seen.add(abs);
+    const source = resolver.read(abs);
+    if (source === null) return hit.raw;
+    return applyImportConditions(expand(stripCharset(source), abs, resolver, seen), hit.conditions);
+  }
+  function inlineCssImports(css, importerAbs, resolver) {
+    return expand(css, importerAbs, resolver, /* @__PURE__ */ new Set([importerAbs]));
+  }
+  var CssImportError, IMPORT_KEYWORD, EXTERNAL_SPEC;
+  var init_css_imports = __esm({
+    "src/css-imports.ts"() {
+      "use strict";
+      CssImportError = class extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "CssImportError";
+        }
+      };
+      IMPORT_KEYWORD = "@import";
+      EXTERNAL_SPEC = /^(?:[A-Za-z][A-Za-z0-9+.-]*:|\/\/)/i;
+    }
+  });
+
   // src/preview-server.ts
   var preview_server_exports = {};
   __export(preview_server_exports, {
@@ -918,6 +1220,20 @@ var AdepWebContainer = (() => {
     if (!vfs.exists(abs) || vfs.isDirectory(abs)) return null;
     return abs;
   }
+  function cssResolverOf(vfs) {
+    return {
+      read: (abs) => vfs.exists(abs) && !vfs.isDirectory(abs) ? vfs.readFile(abs) : null,
+      resolve: (spec, importerAbs) => {
+        if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/"))
+          return resolveLocal(vfs, spec, dirname(importerAbs));
+        try {
+          return resolveImport(vfs, spec, importerAbs, "import");
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
   function inlineAssets(html, vfs, baseDir) {
     let out = html.replace(
       /<script\b([^>]*?)\bsrc\s*=\s*(["'])(.*?)\2([^>]*)><\/script>/gi,
@@ -934,7 +1250,13 @@ var AdepWebContainer = (() => {
       (whole, _pre, _q, _post, _r, orig) => {
         const abs = resolveLocal(vfs, orig, baseDir);
         if (abs === null) return whole;
-        return `<style>${vfs.readFile(abs)}</style>`;
+        const css = vfs.readFile(abs);
+        try {
+          return `<style>${inlineCssImports(css, abs, cssResolverOf(vfs))}</style>`;
+        } catch (error) {
+          if (error instanceof CssImportError) return `<style>${css}</style>`;
+          throw error;
+        }
       }
     );
     return out;
@@ -1007,6 +1329,8 @@ var AdepWebContainer = (() => {
     "src/preview-server.ts"() {
       "use strict";
       init_path();
+      init_node_resolve();
+      init_css_imports();
       EXTERNAL_SRC = /(?:^https?:)?\/\//i;
     }
   });
@@ -1218,7 +1542,8 @@ var AdepWebContainer = (() => {
           '    if (u.pathname.indexOf("/api/") !== 0 && u.pathname !== "/api") {',
           "      return ORIGINAL_FETCH(input, init);",
           "    }",
-          "    if (window.parent === window) return ORIGINAL_FETCH(input, init);",
+          "    var bridgeWindow = window.parent !== window ? window.parent : window.opener;",
+          "    if (!bridgeWindow) return ORIGINAL_FETCH(input, init);",
           '    method = (method || "GET").toUpperCase();',
           "    var target = u.pathname + u.search;",
           "    return readBody(input, init).then(function (textBody) {",
@@ -1229,10 +1554,75 @@ var AdepWebContainer = (() => {
           `          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 }, "*");',
+          '        bridgeWindow.postMessage({ __adepFnRequest: true, id: id, method: method, url: target, headers: headers, body: textBody }, "*");',
           "      });",
           "    });",
           "  };",
+          "",
+          "  /* \u2014\u2014 blob URL SPA \u8DEF\u7531\u652F\u6301 \u2014\u2014",
+          "     blob: \u662F\u4E0D\u53EF\u5206\u5C42 scheme\uFF0Chistory.pushState('/about') \u5185\u90E8\u89E3\u6790\u76F8\u5BF9\u8DEF\u5F84\u4F1A\u629B",
+          "     TypeError \u2192 SPA history \u6A21\u5F0F\u8DEF\u7531\u5D29\u6E83\u3002patch pushState/replaceState\uFF0C\u5BF9\u76F8\u5BF9",
+          "     \u8DEF\u5F84\u76F4\u63A5\u541E\u6389\uFF08\u4E0D\u5BFC\u822A\u3001\u4E0D\u629B\u9519\uFF09\uFF0C\u8DEF\u7531\u5E93\u5185\u90E8\u72B6\u6001\u81EA\u884C\u66F4\u65B0\uFF1Blocation.pathname",
+          "     \u8986\u76D6\u4E3A\u5F53\u524D\u8DEF\u7531\u8DEF\u5F84\uFF0C\u4F9B\u8DEF\u7531\u5E93\u521D\u59CB\u5316\u65F6\u8BFB\u53D6\u3002sessionStorage \u6301\u4E45\u5316\uFF0C\u5237\u65B0\u540E\u6062\u590D\u3002 */",
+          '  if (window.location.protocol === "blob:") {',
+          '    var SPA_KEY = "__adep_spa_path";',
+          '    var spaPath = "/";',
+          "    try {",
+          "      var _saved = window.sessionStorage.getItem(SPA_KEY);",
+          "      if (_saved) spaPath = _saved;",
+          "    } catch (e) {}",
+          "    try {",
+          '      Object.defineProperty(window.location, "pathname", {',
+          "        get: function () { return spaPath; },",
+          "        configurable: true",
+          "      });",
+          "    } catch (e) {}",
+          "    var _origPush = window.history.pushState.bind(window.history);",
+          "    var _origReplace = window.history.replaceState.bind(window.history);",
+          "    function _isRelative(url) {",
+          '      if (!url || typeof url !== "string") return false;',
+          '      if (url.charAt(0) === "#") return false;',
+          "      if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url)) return false;",
+          "      return true;",
+          "    }",
+          "    function _resolvePath(url) {",
+          '      var qi = url.indexOf("?");',
+          '      var hi = url.indexOf("#");',
+          "      var end = url.length;",
+          "      if (qi !== -1) end = qi;",
+          "      if (hi !== -1 && hi < end) end = hi;",
+          "      var p = url.slice(0, end);",
+          '      if (p.charAt(0) !== "/") {',
+          '        var base = spaPath.slice(0, spaPath.lastIndexOf("/") + 1);',
+          "        p = base + p;",
+          "      }",
+          '      var parts = p.split("/");',
+          "      var out = [];",
+          "      for (var i = 0; i < parts.length; i++) {",
+          "        var seg = parts[i];",
+          '        if (seg === "" || seg === ".") continue;',
+          '        if (seg === "..") { out.pop(); continue; }',
+          "        out.push(seg);",
+          "      }",
+          '      return "/" + out.join("/");',
+          "    }",
+          "    window.history.pushState = function (state, title, url) {",
+          "      if (_isRelative(url)) {",
+          "        spaPath = _resolvePath(url);",
+          "        try { window.sessionStorage.setItem(SPA_KEY, spaPath); } catch (e) {}",
+          "        return;",
+          "      }",
+          "      return _origPush(state, title, url);",
+          "    };",
+          "    window.history.replaceState = function (state, title, url) {",
+          "      if (_isRelative(url)) {",
+          "        spaPath = _resolvePath(url);",
+          "        try { window.sessionStorage.setItem(SPA_KEY, spaPath); } catch (e) {}",
+          "        return;",
+          "      }",
+          "      return _origReplace(state, title, url);",
+          "    };",
+          "  }",
           "})();"
         ].join("\n");
         return src;
@@ -1240,12 +1630,76 @@ var AdepWebContainer = (() => {
     }
   });
 
+  // src/console-relay.ts
+  var CONSOLE_RELAY_SCRIPT;
+  var init_console_relay = __esm({
+    "src/console-relay.ts"() {
+      "use strict";
+      CONSOLE_RELAY_SCRIPT = [
+        "(function () {",
+        "  if (window.__adepErrorRelayInstalled) return;",
+        "  window.__adepErrorRelayInstalled = true;",
+        '  var LEVELS = { log: "log", info: "info", warn: "warn", error: "error", debug: "log" };',
+        "  function fmt(value) {",
+        "    try {",
+        '      if (typeof value === "string") return value;',
+        '      if (value === undefined) return "undefined";',
+        "      var seen = [];",
+        "      var json = JSON.stringify(value, function (key, val) {",
+        '        if (val instanceof Error) return val.stack || (val.name + ": " + val.message);',
+        '        if (typeof val === "function") return "[Function " + (val.name || "anonymous") + "]";',
+        '        if (typeof val === "bigint") return String(val) + "n";',
+        '        if (val && typeof val === "object") {',
+        '          if (seen.indexOf(val) !== -1) return "[Circular]";',
+        "          seen.push(val);",
+        "        }",
+        "        return val;",
+        "      });",
+        "      return json === undefined ? String(value) : json;",
+        "    } catch {",
+        "      return String(value);",
+        "    }",
+        "  }",
+        "  function send(level, args) {",
+        "    try {",
+        "      if (window.parent === window) return;",
+        '      var text = Array.prototype.map.call(args, fmt).join(" ");',
+        '      window.parent.postMessage({ source: "adep-ide-preview", kind: "console", level: level, text: text }, "*");',
+        "    } catch {",
+        "    }",
+        "  }",
+        "  Object.keys(LEVELS).forEach(function (name) {",
+        "    var native = console[name];",
+        "    console[name] = function () {",
+        "      send(LEVELS[name], arguments);",
+        "      native.apply(console, arguments);",
+        "    };",
+        "  });",
+        "  window.addEventListener('error', function (event) {",
+        '    var text = event.message || "Script error";',
+        "    if (event.filename) {",
+        '      text += " (" + event.filename + ":" + event.lineno + ":" + event.colno + ")";',
+        "    }",
+        '    send("error", [text]);',
+        "  });",
+        "  window.addEventListener('unhandledrejection', function (event) {",
+        "    var reason = event.reason;",
+        '    var text = reason && reason.stack ? String(reason.stack) : "Unhandled rejection: " + fmt(reason);',
+        '    send("error", [text]);',
+        "  });",
+        "})();",
+        ""
+      ].join("\n");
+    }
+  });
+
   // src/vite-dev.ts
   var vite_dev_exports = {};
   __export(vite_dev_exports, {
     ViteDevError: () => ViteDevError,
     createViteServer: () => createViteServer,
-    scanEsmSpecifiers: () => scanEsmSpecifiers
+    scanEsmSpecifiers: () => scanEsmSpecifiers,
+    scanRequireSpecifiers: () => scanRequireSpecifiers
   });
   function tokenize2(source) {
     const tokens = [];
@@ -1343,6 +1797,20 @@ var AdepWebContainer = (() => {
     }
     return hits;
   }
+  function scanRequireSpecifiers(source) {
+    const tokens = tokenize2(source);
+    const hits = [];
+    for (let i = 0; i + 3 < tokens.length; i++) {
+      const call = tokens[i];
+      if (call.kind !== "ident" || call.text !== "require") continue;
+      if (tokens[i + 1]?.text !== "(") continue;
+      const arg = tokens[i + 2];
+      if (arg.kind !== "string") continue;
+      if (tokens[i + 3]?.text !== ")") continue;
+      hits.push({ specifier: arg.text.slice(1, -1), start: arg.start, end: arg.end });
+    }
+    return hits;
+  }
   function cssModule(css) {
     return [
       `const css = ${JSON.stringify(css)};`,
@@ -1373,6 +1841,113 @@ var AdepWebContainer = (() => {
     }
     return `export default ${source.trim()};`;
   }
+  function stripShebang(source) {
+    if (!source.startsWith("#!")) return source;
+    const nl = source.indexOf("\n");
+    return nl === -1 ? "" : source.slice(nl + 1);
+  }
+  function hasEsmSyntax(source) {
+    const tokens = tokenize2(source);
+    for (let i = 0; i < tokens.length; i++) {
+      const tok = tokens[i];
+      if (tok.kind !== "ident") continue;
+      if (tok.text === "export") return true;
+      if (tok.text === "import" && tokens[i + 1]?.text !== "(") return true;
+    }
+    return false;
+  }
+  function isCommonJs(abs, source) {
+    if (abs.endsWith(".cjs")) return true;
+    if (!abs.endsWith(".js")) return false;
+    if (hasEsmSyntax(source)) return false;
+    return /\bmodule\s*\.\s*exports\b|\bexports\s*\.|\brequire\s*\(/.test(source);
+  }
+  function collectCjsExportNames(source) {
+    const tokens = tokenize2(source);
+    const names = /* @__PURE__ */ new Set();
+    const isIdent = (index) => {
+      const tok = tokens[index];
+      return tok?.kind === "ident" && VALID_IDENT.test(tok.text) ? tok.text : null;
+    };
+    for (let i = 0; i < tokens.length; i++) {
+      const tok = tokens[i];
+      if (tok.kind !== "ident") continue;
+      if (tok.text === "exports") {
+        const name = isIdent(i + 2);
+        if (tokens[i + 1]?.text === "." && name !== null && tokens[i + 3]?.text === "=")
+          names.add(name);
+        continue;
+      }
+      if (tok.text === "module") {
+        const name = isIdent(i + 4);
+        if (tokens[i + 1]?.text === "." && tokens[i + 2]?.text === "exports" && tokens[i + 3]?.text === "." && name !== null && tokens[i + 5]?.text === "=") {
+          names.add(name);
+        }
+        if (tokens[i + 1]?.text === "." && tokens[i + 2]?.text === "exports" && tokens[i + 3]?.text === "=" && tokens[i + 4]?.text === "{") {
+          let depth = 0;
+          for (let j = i + 4; j < tokens.length; j++) {
+            const t = tokens[j];
+            if (t.kind === "string" || t.kind === "template") continue;
+            if (t.text === "{") depth++;
+            else if (t.text === "}") {
+              depth--;
+              if (depth === 0) break;
+            } else if (depth === 1) {
+              const prev = tokens[j - 1]?.text;
+              const key = isIdent(j);
+              const next = tokens[j + 1]?.text;
+              if (key !== null && (prev === "{" || prev === ",") && (next === ":" || next === "," || next === "}")) {
+                names.add(key);
+              }
+            }
+          }
+          continue;
+        }
+        continue;
+      }
+      if (tok.text === "Object") {
+        if (tokens[i + 1]?.text === "." && tokens[i + 2]?.text === "defineProperty" && tokens[i + 3]?.text === "(" && tokens[i + 4]?.text === "exports" && tokens[i + 5]?.text === "," && tokens[i + 6]?.kind === "string") {
+          names.add(tokens[i + 6].text.slice(1, -1));
+        }
+      }
+    }
+    names.delete("default");
+    return [...names].filter((name) => VALID_IDENT.test(name) && !CJS_INTERNALS.has(name));
+  }
+  function wrapCommonJs(abs, source) {
+    const specifiers = [...new Set(scanRequireSpecifiers(source).map((hit) => hit.specifier))];
+    const prelude = specifiers.map(
+      (spec, index) => `import * as ${CJS_PREFIX}Dep${index} from ${JSON.stringify(CJS_SPECIFIER_PREFIX + spec)};`
+    );
+    const entries = specifiers.map(
+      (spec, index) => `${JSON.stringify(spec)}: ${CJS_PREFIX}Dep${index}`
+    );
+    const names = collectCjsExportNames(source);
+    const detail = JSON.stringify(
+      `${abs} \u91CC\u7684 require() \u8BF4\u660E\u7B26\u65E0\u6CD5\u89E3\u6790\uFF08Node \u5185\u5EFA\u6A21\u5757\u6D4F\u89C8\u5668\u4E0D\u63D0\u4F9B / \u4F9D\u8D56\u672A\u5B89\u88C5 / \u52A8\u6001\u62FC\u63A5\uFF09`
+    );
+    return [
+      ...prelude,
+      `const ${CJS_PREFIX}Map = { ${entries.join(", ")} };`,
+      `const ${CJS_PREFIX}Require = (id) => {`,
+      `  const ns = ${CJS_PREFIX}Map[id];`,
+      `  if (ns === undefined || ns.${CJS_PREFIX}Unresolved === true)`,
+      `    throw new Error('require(' + JSON.stringify(id) + ') \u65E0\u6CD5\u89E3\u6790\uFF1A' + ${detail});`,
+      `  return ns[${JSON.stringify(CJS_EXPORTS_MARKER)}] !== undefined ? ns[${JSON.stringify(CJS_EXPORTS_MARKER)}] : ns;`,
+      `};`,
+      `const ${CJS_PREFIX}Module = { exports: {} };`,
+      "(function (module, exports, require) {",
+      source,
+      `}).call(${CJS_PREFIX}Module.exports, ${CJS_PREFIX}Module, ${CJS_PREFIX}Module.exports, ${CJS_PREFIX}Require);`,
+      `const ${CJS_EXPORTS_MARKER}Value = ${CJS_PREFIX}Module.exports;`,
+      `export const ${CJS_EXPORTS_MARKER} = ${CJS_EXPORTS_MARKER}Value;`,
+      `const ${CJS_PREFIX}Default = ${CJS_EXPORTS_MARKER}Value && ${CJS_EXPORTS_MARKER}Value.__esModule ? ${CJS_EXPORTS_MARKER}Value.default : ${CJS_EXPORTS_MARKER}Value;`,
+      `export default ${CJS_PREFIX}Default;`,
+      ...names.map(
+        (name) => `export const ${name} = ${CJS_EXPORTS_MARKER}Value[${JSON.stringify(name)}];`
+      )
+    ].join("\n");
+  }
   function resolveWithSuffixes(vfs, base) {
     if (vfs.exists(base) && !vfs.isDirectory(base)) return base;
     const asFile2 = VITE_RESOLVE_SUFFIXES.map((suffix) => `${base}${suffix}`);
@@ -1419,15 +1994,42 @@ var AdepWebContainer = (() => {
       [/\bprocess\s*\.\s*env\s*\.\s*NODE_ENV\b/g, JSON.stringify("development")],
       [/\b__VUE_OPTIONS_API__\b/g, "true"],
       [/\b__VUE_PROD_DEVTOOLS__\b/g, "false"],
-      [/\b__VUE_PROD_HYDRATION_MISMATCH_DETAILS__\b/g, "false"]
+      [/\b__VUE_PROD_HYDRATION_MISMATCH_DETAILS__\b/g, "false"],
+      [
+        /\bimport\s*\.\s*meta\s*\.\s*env\b/g,
+        '({ BASE_URL: "/", MODE: "development", DEV: true, PROD: false, SSR: false })'
+      ]
     ];
     function applyDefines(code) {
       let out = code;
       for (const [pattern, value] of DEFINES) out = out.replace(pattern, value);
       return out;
     }
+    const cssResolver = {
+      read: (abs) => vfs.exists(abs) && !vfs.isDirectory(abs) ? vfs.readFile(abs) : null,
+      resolve: (spec, importerAbs) => {
+        if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
+          const base = spec.startsWith("/") ? absoluteFromRoot(spec) : join(dirname(importerAbs), spec);
+          const target = resolveWithSuffixes(vfs, base);
+          return vfs.exists(target) && !vfs.isDirectory(target) ? target : null;
+        }
+        try {
+          return resolveImport(vfs, spec, importerAbs, "import");
+        } catch {
+          return null;
+        }
+      }
+    };
+    function inlineCss(css, importerAbs) {
+      try {
+        return inlineCssImports(css, importerAbs, cssResolver);
+      } catch (error) {
+        if (error instanceof CssImportError) throw new ViteDevError("CSS_IMPORT", error.message);
+        throw error;
+      }
+    }
     function transformModule2(abs, source) {
-      if (abs.endsWith(".css")) return cssModule(source);
+      if (abs.endsWith(".css")) return cssModule(inlineCss(source, abs));
       if (abs.endsWith(".json")) return jsonModule(source, abs);
       if (abs.endsWith(".vue")) {
         if (sfcCompiler === void 0)
@@ -1437,7 +2039,9 @@ var AdepWebContainer = (() => {
           );
         const compiled = sfcCompiler(source, abs);
         return [
-          ...compiled.styles.map((css, index) => inlineStyleBlock(css, `${abs}#${index}`)),
+          ...compiled.styles.map(
+            (css, index) => inlineStyleBlock(inlineCss(css, abs), `${abs}#${index}`)
+          ),
           applyDefines(stripTypes(compiled.script))
         ].join("\n");
       }
@@ -1446,37 +2050,65 @@ var AdepWebContainer = (() => {
           "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 applyDefines(stripTypes(source));
-      return applyDefines(source);
+      const bare = stripShebang(source);
+      if (abs.endsWith(".ts") || abs.endsWith(".mts")) return applyDefines(stripTypes(bare));
+      if (isCommonJs(abs, bare)) return applyDefines(wrapCommonJs(abs, bare));
+      return applyDefines(bare);
     }
     function absoluteFromRoot(spec) {
       return join(root, spec.replace(/^\/+/, ""));
     }
-    async function resolveSpecifier(spec, importerAbs) {
-      if (EXTERNAL_SPECIFIER.test(spec) || DATA_OR_BLOB.test(spec)) return spec;
-      let target;
+    function resolveToAbs(spec, importerAbs) {
       if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
         const base = spec.startsWith("/") ? absoluteFromRoot(spec) : join(dirname(importerAbs), spec);
-        target = resolveWithSuffixes(vfs, base);
+        const 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}
+        return target;
+      }
+      try {
+        return 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;
+          );
+        throw error;
+      }
+    }
+    const cjsStubSources = /* @__PURE__ */ new Map();
+    function cjsStubUrl(spec) {
+      let abs = cjsStubSources.get(spec);
+      if (abs === void 0) {
+        abs = `${INLINE_PREFIX}cjs_stub_${cjsStubSources.size}.mjs`;
+        cjsStubSources.set(spec, abs);
+        inlineSources.set(
+          abs,
+          [
+            `export const ${CJS_PREFIX}Unresolved = true;`,
+            `export const ${CJS_PREFIX}Specifier = ${JSON.stringify(spec)};`,
+            "export default undefined;"
+          ].join("\n")
+        );
+      }
+      return loadModuleUrl(abs);
+    }
+    async function resolveSpecifier(spec, importerAbs) {
+      if (spec.startsWith(CJS_SPECIFIER_PREFIX)) {
+        const original = spec.slice(CJS_SPECIFIER_PREFIX.length);
+        try {
+          return await loadModuleUrl(resolveToAbs(original, importerAbs));
+        } catch {
+          return cjsStubUrl(original);
         }
       }
-      return loadModuleUrl(target);
+      if (EXTERNAL_SPECIFIER.test(spec) || DATA_OR_BLOB.test(spec)) return spec;
+      return loadModuleUrl(resolveToAbs(spec, importerAbs));
     }
     async function loadModuleUrl(abs) {
       const cached = moduleUrls.get(abs);
@@ -1568,14 +2200,15 @@ var AdepWebContainer = (() => {
       );
       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 preludeScripts = `<script>${CONSOLE_RELAY_SCRIPT}<\/script><script>${FN_FETCH_INTERCEPTOR_SCRIPT}<\/script>`;
+      html = /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (m) => `${m}${preludeScripts}`) : `${preludeScripts}${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();
+      cjsStubSources.clear();
       inlineSeq = 0;
       let doc;
       try {
@@ -1585,9 +2218,13 @@ var AdepWebContainer = (() => {
       }
       const changed = lastDoc !== null && doc !== lastDoc;
       lastDoc = doc;
+      if (!changed && currentUrl !== "") return;
       if (currentUrl !== "") revokeObjectURL(currentUrl);
       currentUrl = createObjectURL(new Blob([doc], { type: "text/html" }));
-      if (changed) broadcast(currentUrl);
+      if (changed) {
+        broadcast(currentUrl);
+        options.onDocumentChange?.(currentUrl);
+      }
     }
     const server = {
       get url() {
@@ -1620,7 +2257,7 @@ var AdepWebContainer = (() => {
     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 ViteDevError, REGEX_PRECEDING_CHARS, REGEX_PRECEDING_KEYWORDS, isIdentStart, isIdentPart, CJS_PREFIX, CJS_EXPORTS_MARKER, CJS_SPECIFIER_PREFIX, VALID_IDENT, CJS_INTERNALS, 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";
@@ -1629,6 +2266,8 @@ var AdepWebContainer = (() => {
       init_strip_types();
       init_preview_server();
       init_function_fetch_proxy();
+      init_console_relay();
+      init_css_imports();
       ViteDevError = class extends Error {
         constructor(reason, message) {
           super(message);
@@ -1677,6 +2316,22 @@ var AdepWebContainer = (() => {
       ]);
       isIdentStart = (ch) => /[A-Za-z_$]/.test(ch);
       isIdentPart = (ch) => /[A-Za-z0-9_$]/.test(ch);
+      CJS_PREFIX = "__adepCjs";
+      CJS_EXPORTS_MARKER = `${CJS_PREFIX}Exports`;
+      CJS_SPECIFIER_PREFIX = `${CJS_PREFIX}Spec:`;
+      VALID_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+      CJS_INTERNALS = /* @__PURE__ */ new Set([
+        "module",
+        "exports",
+        "require",
+        // 互操作标记而非用户导出：Babel 产物会 defineProperty(exports, "__esModule")，转发它没有意义。
+        "__esModule",
+        `${CJS_EXPORTS_MARKER}`,
+        `${CJS_PREFIX}Default`,
+        `${CJS_PREFIX}Map`,
+        `${CJS_PREFIX}Module`,
+        `${CJS_PREFIX}Require`
+      ]);
       VITE_RESOLVE_SUFFIXES = [".ts", ".js", ".mjs", ".mts", ".vue", ".json", ".css"];
       INLINE_PREFIX = "/__vite_inline_";
       EXTERNAL_SPECIFIER = /^(?:https?:)?\/\//i;
@@ -1689,7 +2344,9 @@ var AdepWebContainer = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    BUNDLE_MODULE_PATH_PREFIX: () => BUNDLE_MODULE_PATH_PREFIX,
     COMPLETABLE_COMMANDS: () => COMPLETABLE_COMMANDS,
+    CONSOLE_RELAY_SCRIPT: () => CONSOLE_RELAY_SCRIPT,
     DEFAULT_MAX_INSTALL_DEPTH: () => DEFAULT_MAX_INSTALL_DEPTH,
     EXTRA_COMMANDS: () => EXTRA_COMMANDS,
     FN_FETCH_INTERCEPTOR_SCRIPT: () => FN_FETCH_INTERCEPTOR_SCRIPT,
@@ -1734,12 +2391,15 @@ var AdepWebContainer = (() => {
     createViteServer: () => createViteServer,
     createWorkerRuntime: () => createWorkerRuntime,
     deepEqual: () => deepEqual,
+    defaultModuleName: () => defaultModuleName,
     displayPath: () => displayPath,
     entriesToTree: () => entriesToTree,
     evaluateModuleSource: () => evaluateModuleSource,
     evaluateSource: () => evaluateSource,
     exampleTestSource: () => exampleTestSource,
     expectAssertion: () => expect,
+    exportBundle: () => exportBundle,
+    findBlobRefs: () => findBlobRefs,
     formatTestReport: () => formatTestReport,
     formatValue: () => formatValue,
     fullName: () => fullName,
@@ -2823,7 +3483,7 @@ var AdepWebContainer = (() => {
 
   // src/npm-client.ts
   init_node_resolve();
-  var DEFAULT_MAX_INSTALL_DEPTH = 5;
+  var DEFAULT_MAX_INSTALL_DEPTH = 25;
   var defaultFetch = (url, init) => globalThis.fetch(url, init).then((res) => res);
   function parseSpec(spec) {
     if (spec.startsWith("@")) {
@@ -2848,29 +3508,50 @@ var AdepWebContainer = (() => {
       throw new Error(`${what} \u5931\u8D25\uFF1A\u65E0\u6CD5\u8BBF\u95EE npm \u4E2D\u7EE7\uFF08${url}\uFF0C${reason}\uFF09`, { cause: error });
     }
   }
+  var RATE_LIMIT_MAX_RETRIES = 120;
+  var DEFAULT_RETRY_AFTER_MS = 1e3;
+  var MAX_RETRY_AFTER_MS = 6e4;
+  var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  function retryAfterMs(res) {
+    const raw = res.headers["retry-after"];
+    const seconds = raw === void 0 ? Number.NaN : Number.parseFloat(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) return DEFAULT_RETRY_AFTER_MS;
+    return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+  }
   function createNpmClient(options) {
     const fetchImpl = options.fetchImpl ?? defaultFetch;
     const base = options.baseUrl.replace(/\/+$/, "");
     const storage = options.storage;
     const maxDepth = options.maxDepth ?? DEFAULT_MAX_INSTALL_DEPTH;
+    const sleep = options.sleep ?? defaultSleep;
+    async function relayRequest(url, what) {
+      for (let attempt = 0; ; attempt += 1) {
+        const res = await relayFetch(fetchImpl, url, what);
+        if (res.status !== 429) return res;
+        if (attempt >= RATE_LIMIT_MAX_RETRIES) {
+          throw new Error(
+            `${what} \u5931\u8D25\uFF1Anpm \u4E2D\u7EE7\u9650\u901F\uFF08HTTP 429\uFF09\uFF0C\u5DF2\u6309 Retry-After \u9000\u907F\u91CD\u8BD5 ${attempt} \u6B21\u4ECD\u88AB\u62D2\u2014\u2014\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002`
+          );
+        }
+        await sleep(retryAfterMs(res));
+      }
+    }
     async function resolvePackage(name, spec) {
       const params = new URLSearchParams({ name });
       if (spec !== void 0) params.set("spec", spec);
-      const res = await relayFetch(
-        fetchImpl,
+      const res = await relayRequest(
         `${base}/package?${params.toString()}`,
         `\u89E3\u6790\u5305 ${name}@${spec ?? "latest"}`
       );
       if (!res.ok) {
         throw new Error(
-          `\u89E3\u6790\u5305\u5931\u8D25 ${name}@${spec ?? "latest"}\uFF1AHTTP ${res.status}\uFF08\u4E0D\u5728\u767D\u540D\u5355\u6216\u5305\u4E0D\u5B58\u5728\u65F6\u7531\u4E2D\u7EE7\u62D2\u7EDD\uFF09`
+          `\u89E3\u6790\u5305\u5931\u8D25 ${name}@${spec ?? "latest"}\uFF1AHTTP ${res.status}\uFF08\u4E2D\u7EE7\u62D2\u7EDD\uFF1A\u5305\u4E0D\u5B58\u5728 / registry \u4E0D\u53EF\u8FBE / registry \u975E\u767D\u540D\u5355\uFF09`
         );
       }
       return await res.json();
     }
     async function fetchAndUnpack(name, version) {
-      const res = await relayFetch(
-        fetchImpl,
+      const res = await relayRequest(
         `${base}/tarball?${new URLSearchParams({ name, version }).toString()}`,
         `\u4E0B\u8F7D tarball ${name}@${version}`
       );
@@ -2894,17 +3575,12 @@ var AdepWebContainer = (() => {
         return null;
       }
     }
-    async function collect(name, spec, depth, path, staged, onStack, visited, packages, distTagsByName) {
+    async function collect(name, spec, depth, path, staged, visited, packages, distTagsByName) {
       if (depth > maxDepth) {
         throw new Error(
           `\u4F9D\u8D56\u5C42\u7EA7\u8D85\u8FC7\u4E0A\u9650\uFF08${maxDepth}\uFF09\uFF1A${[...path, name].join(" \u2192 ")}\u3002\u8BF7\u6539\u7528\u66F4\u8F7B\u7684\u5305\u6216\u7ECF\u670D\u52A1\u7AEF\u53D1\u5E03\u94FE\u8DEF\u5B89\u88C5\uFF08FN-009 \u5B9E\u65F6\u88C5\u8F7D\uFF09\u3002`
         );
       }
-      if (onStack.has(name)) {
-        throw new Error(
-          `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56\uFF1A${[...path, name].join(" \u2192 ")}\u3002\u6D4F\u89C8\u5668\u5B89\u88C5\u4E0D\u652F\u6301\u73AF\u72B6\u4F9D\u8D56\u6811\uFF0C\u8BF7\u79FB\u9664\u73AF\u4E0A\u5305\u7684\u76F8\u4E92\u58F0\u660E\u3002`
-        );
-      }
       const meta = await resolvePackage(name, spec);
       distTagsByName.set(meta.name, meta.distTags ?? []);
       const key = `${meta.name}@${meta.version}`;
@@ -2928,8 +3604,6 @@ var AdepWebContainer = (() => {
         }
         Object.assign(deps, pkgMeta.dependencies ?? {});
       }
-      const nextStack = new Set(onStack);
-      nextStack.add(meta.name);
       for (const [depName, depSpec] of Object.entries(deps)) {
         await collect(
           depName,
@@ -2937,7 +3611,6 @@ var AdepWebContainer = (() => {
           depth + 1,
           [...path, meta.name],
           staged,
-          nextStack,
           visited,
           packages,
           distTagsByName
@@ -2946,7 +3619,7 @@ var AdepWebContainer = (() => {
     }
     return {
       async registries() {
-        const res = await relayFetch(fetchImpl, `${base}/registry`, "\u83B7\u53D6 registry \u5217\u8868");
+        const res = await relayRequest(`${base}/registry`, "\u83B7\u53D6 registry \u5217\u8868");
         if (!res.ok) throw new Error(`\u83B7\u53D6 registry \u5217\u8868\u5931\u8D25\uFF1AHTTP ${res.status}`);
         const body = await res.json();
         return body.registries;
@@ -2956,7 +3629,7 @@ var AdepWebContainer = (() => {
         const staged = /* @__PURE__ */ new Map();
         const packages = [];
         const distTagsByName = /* @__PURE__ */ new Map();
-        await collect(name, spec, 1, [], staged, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), packages, distTagsByName);
+        await collect(name, spec, 1, [], staged, /* @__PURE__ */ new Set(), packages, distTagsByName);
         const root = packages[0] ?? { name, version: spec ?? "latest" };
         const downloaded = staged.size > 0;
         for (const [path, contents] of staged) storage.writeFile(path, contents);
@@ -3711,7 +4384,11 @@ self.onmessage = async (event) => {
         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 }
+          ...options.viteCompiler === void 0 ? {} : { sfcCompiler: options.viteCompiler },
+          // PV-006：内容重建 → 以 `serverready`（update: true）事件上报新文档 URL，宿主导出预览产物。
+          onDocumentChange: (url) => {
+            emit("serverready", { port: server.port, url, kind: "vite", root: server.root, update: true });
+          }
         });
         await server.ready;
         viteServer = server;
@@ -3876,6 +4553,92 @@ self.onmessage = async (event) => {
   init_vite_dev();
   init_path();
 
+  // src/bundle-export.ts
+  var BUNDLE_MODULE_PATH_PREFIX = "/_adep/m/";
+  var BLOB_REF_RE = /blob:[^\s"'`<>()\\]+/g;
+  function fnv1a(code) {
+    let hash = 2166136261;
+    for (let i = 0; i < code.length; i++) {
+      hash ^= code.charCodeAt(i);
+      hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return `${hash.toString(16).padStart(8, "0")}${code.length.toString(16)}`;
+  }
+  async function defaultModuleName(code) {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === void 0) return fnv1a(code);
+    const digest = await subtle.digest("SHA-256", new TextEncoder().encode(code));
+    let hex = "";
+    for (const byte of new Uint8Array(digest).slice(0, 8)) {
+      hex += byte.toString(16).padStart(2, "0");
+    }
+    return hex;
+  }
+  function findBlobRefs(text) {
+    const found = text.match(BLOB_REF_RE);
+    return found === null ? [] : [...new Set(found)];
+  }
+  function rewriteRefs(text, urls) {
+    let out = text;
+    for (const [blobUrl, path] of urls) {
+      if (out.includes(blobUrl)) out = out.split(blobUrl).join(path);
+    }
+    return out;
+  }
+  function injectScript(html, script) {
+    return /<\/body>/i.test(html) ? html.replace(/<\/body>/i, `${script}</body>`) : html + script;
+  }
+  async function exportBundle(options) {
+    const readText = options.readText ?? ((url) => fetch(url).then((response) => response.text()));
+    const nameOf = options.moduleName ?? defaultModuleName;
+    const prefix = options.modulePathPrefix ?? BUNDLE_MODULE_PATH_PREFIX;
+    const uploaded = new Set(options.known === void 0 ? [] : [...options.known.values()]);
+    const urls = /* @__PURE__ */ new Map();
+    const sources = [];
+    const readOrThrow = async (url) => {
+      try {
+        return await readText(url);
+      } catch (error) {
+        throw new Error(
+          `\u9884\u89C8\u4EA7\u7269\u5BFC\u51FA\u5931\u8D25\uFF1A\u8BFB\u4E0D\u5230\u6A21\u5757 ${url}\uFF08${error instanceof Error ? error.message : String(error)}\uFF09`,
+          { cause: error }
+        );
+      }
+    };
+    const html = await readOrThrow(options.documentUrl);
+    const loadLayer = async (layer) => {
+      const batch = [...new Set(layer)].filter((url) => !urls.has(url));
+      if (batch.length === 0) return;
+      const loaded = await Promise.all(
+        batch.map(async (url) => {
+          const code = await readOrThrow(url);
+          return { url, code, path: `${prefix}${await nameOf(code)}.js` };
+        })
+      );
+      const next = [];
+      for (const item of loaded) {
+        urls.set(item.url, item.path);
+        sources.push({ url: item.url, code: item.code });
+        next.push(...findBlobRefs(item.code));
+      }
+      await loadLayer(next);
+    };
+    await loadLayer(findBlobRefs(html));
+    const modules = {};
+    for (const { url, code } of sources) {
+      const path = urls.get(url);
+      if (uploaded.has(path)) continue;
+      modules[path] = rewriteRefs(code, urls);
+    }
+    const rewrittenHtml = rewriteRefs(html, urls);
+    return {
+      html: options.appendScript === void 0 ? rewrittenHtml : injectScript(rewrittenHtml, options.appendScript),
+      modules,
+      paths: [...new Set(urls.values())].toSorted(),
+      urls
+    };
+  }
+
   // src/persistence.ts
   function cloneEntries(entries) {
     return entries.map(
@@ -5427,6 +6190,7 @@ self.onmessage = async (event) => {
     const t = raw.trim();
     if (/^'.*'$/.test(t)) return t.slice(1, -1);
     if (/^".*"$/.test(t)) return t.slice(1, -1);
+    if (/^NULL$/i.test(t)) return null;
     return t;
   }
   function parseCreateTable(ddl) {
@@ -5447,50 +6211,109 @@ self.onmessage = async (event) => {
     }
     return { name, columns };
   }
-  function parseWhereClauses(whereRaw, cursor) {
-    const clauses = [];
-    for (const part of whereRaw.split(/\s+AND\s+/i)) {
-      const t = part.trim();
-      if (t.length === 0) continue;
-      if (/\bIS\s+NULL\b/i.test(t)) {
-        const col2 = ident(t.split(/\s+IS\s+NULL\b/i)[0] ?? "");
-        clauses.push({ column: col2, operator: "IS NULL", value: null, list: false });
-        continue;
-      }
-      if (/\bIS\s+NOT\s+NULL\b/i.test(t)) {
-        const col2 = ident(t.split(/\s+IS\s+NOT\s+NULL\b/i)[0] ?? "");
-        clauses.push({ column: col2, operator: "IS NOT NULL", value: null, list: false });
-        continue;
-      }
-      const opMatch = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*(=|!=|>=|<=|>|<|like|in|not\s+in)\s*(.+)$/i.exec(
-        t
-      );
-      if (opMatch === null) continue;
-      const col = ident(opMatch[1] ?? "");
-      const op = (opMatch[3] ?? opMatch[2] ?? "").toLowerCase();
-      const rhs = (opMatch[4] ?? "").trim();
-      if (op === "in" || op === "not in") {
-        const inner = rhs.replace(/^\(|\)$/g, "");
-        const items = splitListItems(inner);
-        const list = items.map((item) => {
-          if (item.trim() === "?") return cursor.take();
-          return stripQuotes(item);
-        });
-        clauses.push({ column: col, operator: op, value: list, list: true });
+  function splitTopLevel(raw, token) {
+    const parts = [];
+    let depth = 0;
+    let inQuote = false;
+    let buffer = "";
+    const n = raw.length;
+    const isTokenAt = (i) => {
+      const word = raw.slice(i, i + token.length);
+      if (word.toUpperCase() !== token) return false;
+      const before = i === 0 ? "" : raw[i - 1] ?? "";
+      const after = raw[i + token.length] ?? "";
+      return !/[A-Za-z0-9_.]/.test(before) && !/[A-Za-z0-9_.]/.test(after);
+    };
+    for (let i = 0; i < n; i += 1) {
+      const ch = raw[i] ?? "";
+      if (ch === "'") {
+        if (inQuote && raw[i + 1] === "'") {
+          buffer += ch + (raw[i + 1] ?? "");
+          i += 1;
+          continue;
+        }
+        inQuote = !inQuote;
+        buffer += ch;
         continue;
       }
-      let value;
-      if (rhs === "?") {
-        value = cursor.take();
+      if (!inQuote && ch === "(") depth += 1;
+      else if (!inQuote && ch === ")") depth -= 1;
+      if (!inQuote && depth === 0 && isTokenAt(i)) {
+        parts.push(buffer);
+        buffer = "";
+        i += token.length - 1;
       } else {
-        value = stripQuotes(rhs);
+        buffer += ch;
       }
-      clauses.push({ column: col, operator: op, value, list: false });
     }
-    return clauses;
+    parts.push(buffer);
+    return parts;
+  }
+  function unqualifyColumn(raw) {
+    const t = raw.trim();
+    const dot = t.lastIndexOf(".");
+    if (dot > 0 && /^[A-Za-z_][A-Za-z0-9_]*\./.test(t)) return t.slice(dot + 1);
+    return t;
+  }
+  function parseLeftJoins(tail) {
+    const joins = [];
+    const re = /LEFT\s+JOIN\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+([A-Za-z_][A-Za-z0-9_]*)\s+ON\s+([A-Za-z_][A-Za-z0-9_.]*)\s*=\s*([A-Za-z_][A-Za-z0-9_.]*)/gi;
+    let m;
+    while ((m = re.exec(tail)) !== null) {
+      joins.push({
+        table: ident(m[1] ?? ""),
+        alias: m[3] ?? "",
+        leftCol: unqualifyColumn(m[4] ?? ""),
+        rightCol: unqualifyColumn(m[5] ?? "")
+      });
+    }
+    return joins;
   }
-  function matchWhere(clauses, row) {
-    return clauses.every((c) => matchValue(row[c.column], c));
+  function parseWhereClauses(whereRaw, cursor) {
+    const parseAndGroup = (andRaw) => {
+      const clauses = [];
+      for (const part of splitTopLevel(andRaw, "AND")) {
+        const t = part.trim();
+        if (t.length === 0) continue;
+        if (/\bIS\s+NULL\b/i.test(t)) {
+          clauses.push({ column: unqualifyColumn(ident(t.split(/\s+IS\s+NULL\b/i)[0] ?? "")), operator: "IS NULL", value: null, list: false });
+          continue;
+        }
+        if (/\bIS\s+NOT\s+NULL\b/i.test(t)) {
+          clauses.push({ column: unqualifyColumn(ident(t.split(/\s+IS\s+NOT\s+NULL\b/i)[0] ?? "")), operator: "IS NOT NULL", value: null, list: false });
+          continue;
+        }
+        const opMatch = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_.]*))\s*(=|!=|>=|<=|>|<|like|in|not\s+in)\s*(.+)$/i.exec(
+          t
+        );
+        if (opMatch === null) continue;
+        const col = unqualifyColumn(ident(opMatch[1] ?? ""));
+        const op = (opMatch[3] ?? opMatch[2] ?? "").toLowerCase();
+        const rhs = (opMatch[4] ?? "").trim();
+        if (op === "in" || op === "not in") {
+          const inner = rhs.replace(/^\(|\)$/g, "");
+          const items = splitListItems(inner);
+          const list = items.map((item) => {
+            if (item.trim() === "?") return cursor.take();
+            return stripQuotes(item);
+          });
+          clauses.push({ column: col, operator: op, value: list, list: true });
+          continue;
+        }
+        let value;
+        if (rhs === "?") {
+          value = cursor.take();
+        } else {
+          value = stripQuotes(rhs);
+        }
+        clauses.push({ column: col, operator: op, value, list: false });
+      }
+      return clauses;
+    };
+    return splitTopLevel(whereRaw, "OR").map((group) => group.trim()).filter((group) => group.length > 0).map(parseAndGroup);
+  }
+  function matchWhere(groups, row) {
+    return groups.some((clauses) => clauses.every((c) => matchValue(row[c.column], c)));
   }
   function splitListItems(inner) {
     const items = [];
@@ -5510,6 +6333,168 @@ self.onmessage = async (event) => {
     items.push(buffer);
     return items;
   }
+  var ExcludedRef = class {
+    constructor(column) {
+      this.column = column;
+    }
+  };
+  var ColumnRef = class {
+    constructor(column) {
+      this.column = column;
+    }
+  };
+  var ExprRef = class {
+    constructor(source) {
+      this.source = source;
+    }
+  };
+  function resolveSetValue(value, existing, row) {
+    if (value instanceof ExcludedRef) return row[value.column];
+    if (value instanceof ColumnRef) return existing[value.column];
+    if (value instanceof ExprRef) return evalArithmetic(value.source, existing, row);
+    return value;
+  }
+  function evalArithmetic(src, existing, row) {
+    const num = (v) => {
+      const n2 = Number(v);
+      return Number.isFinite(n2) ? n2 : 0;
+    };
+    let i = 0;
+    const n = src.length;
+    const skip = () => {
+      while (i < n && /\s/.test(src[i] ?? "")) i += 1;
+    };
+    const peek = () => {
+      skip();
+      return i < n ? src[i] ?? "" : null;
+    };
+    const parseIdent = () => {
+      skip();
+      const m = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(src.slice(i));
+      if (m === null) return null;
+      i += (m[1] ?? "").length;
+      skip();
+      let col = ident(m[1] ?? "");
+      let excluded = false;
+      if (src[i] === ".") {
+        const m2 = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(src.slice(i));
+        if (m2 !== null) {
+          i += (m2[0] ?? "").length;
+          if (col.toLowerCase() === "excluded") excluded = true;
+          col = ident(m2[1] ?? "");
+        }
+      }
+      return { col, excluded };
+    };
+    const parseFactor = () => {
+      const ch = peek();
+      if (ch === "(") {
+        i += 1;
+        const v = parseExpr();
+        skip();
+        if (src[i] === ")") i += 1;
+        return v;
+      }
+      const numMatch = /^(\d+(?:\.\d+)?)/.exec(src.slice(i));
+      if (numMatch !== null) {
+        i += (numMatch[1] ?? "").length;
+        return Number(numMatch[1]);
+      }
+      const id = parseIdent();
+      if (id !== null) {
+        const v = id.excluded ? row[id.col] : existing[id.col];
+        return num(v);
+      }
+      return 0;
+    };
+    const parseTerm = () => {
+      let v = parseFactor();
+      for (; ; ) {
+        const ch = peek();
+        if (ch !== "*" && ch !== "/") return v;
+        i += 1;
+        const rhs = parseFactor();
+        v = ch === "*" ? v * rhs : rhs === 0 ? v : v / rhs;
+      }
+    };
+    const parseExpr = () => {
+      let v = parseTerm();
+      for (; ; ) {
+        const ch = peek();
+        if (ch !== "+" && ch !== "-") return v;
+        i += 1;
+        const rhs = parseTerm();
+        v = ch === "+" ? v + rhs : v - rhs;
+      }
+    };
+    return parseExpr();
+  }
+  function splitInsertTuples(body) {
+    const tuples = [];
+    let i = 0;
+    const n = body.length;
+    while (i < n) {
+      while (i < n && (body[i] === " " || body[i] === "	" || body[i] === "\n" || body[i] === "\r" || body[i] === ",")) {
+        i += 1;
+      }
+      if (i >= n) break;
+      if (body[i] !== "(") {
+        return { tuples, conflict: body.slice(i).trim() };
+      }
+      let depth = 0;
+      let j = i;
+      for (; j < n; j += 1) {
+        if (body[j] === "(") depth += 1;
+        else if (body[j] === ")") {
+          depth -= 1;
+          if (depth === 0) break;
+        }
+      }
+      if (j >= n) return { tuples, conflict: null };
+      tuples.push(body.slice(i + 1, j));
+      i = j + 1;
+    }
+    return { tuples, conflict: null };
+  }
+  function parseConflictClause(clause, cursor, fallbackCols) {
+    const m = /^ON\s+CONFLICT(?:\s*\(([^)]*)\))?\s+DO\s+(UPDATE\s+SET\s+([\s\S]+)|NOTHING\s*)$/i.exec(
+      clause.trim()
+    );
+    if (m === null) {
+      throw new SimDbError("DB_UNSAFE_OP", `\u65E0\u6CD5\u89E3\u6790 ON CONFLICT \u5B50\u53E5\uFF1A${clause.trim().slice(0, 60)}\u2026`);
+    }
+    const colsRaw = m[1];
+    const cols = colsRaw === void 0 ? fallbackCols : colsRaw.split(",").map(ident);
+    if (cols.length === 0) throw new SimDbError("DB_UNSAFE_OP", "ON CONFLICT \u51B2\u7A81\u5217\u4E3A\u7A7A");
+    const action = m[2] ?? "";
+    if (/^NOTHING/i.test(action)) return { cols, sets: [] };
+    const setRaw = m[3] ?? "";
+    const sets = splitListItems(setRaw).map((part) => {
+      const eq = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/i.exec(part.trim());
+      if (eq === null) {
+        throw new SimDbError("DB_UNSAFE_OP", `\u65E0\u6CD5\u89E3\u6790 SET \u8D4B\u503C\uFF1A${part.trim().slice(0, 60)}\u2026`);
+      }
+      const col = ident(eq[1] ?? "");
+      const rhs = (eq[2] ?? "").trim();
+      let value;
+      if (rhs === "?") {
+        value = cursor.take();
+      } else {
+        const ex = /^excluded\.([A-Za-z_][A-Za-z0-9_]*)$/i.exec(rhs);
+        if (ex !== null) {
+          value = new ExcludedRef(ident(ex[1] ?? ""));
+        } else if (/^([A-Za-z_][A-Za-z0-9_]*)$/.test(rhs) && !/^NULL$/i.test(rhs)) {
+          value = new ColumnRef(ident(rhs));
+        } else if (/^'.*'$/.test(rhs) || /^".*"$/.test(rhs) || /^NULL$/i.test(rhs)) {
+          value = stripQuotes(rhs);
+        } else {
+          value = new ExprRef(rhs);
+        }
+      }
+      return { col, value };
+    });
+    return { cols, sets };
+  }
   function matchValue(value, clause) {
     const op = clause.operator;
     if (op === "IS NULL") return value === null || value === void 0;
@@ -5637,6 +6622,17 @@ self.onmessage = async (event) => {
         }
         return { changes: 0 };
       }
+      if (/^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?/i.test(stmt)) {
+        const idx = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+ON\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))/i.exec(
+          stmt
+        );
+        if (idx === null) throw new SimDbError("DB_UNSAFE_OP", `\u65E0\u6CD5\u89E3\u6790 CREATE INDEX \u8BED\u53E5`);
+        const tableName = ident(idx[3]);
+        if (this.tables[tableName] === void 0) {
+          throw new SimDbError("DB_UNSAFE_OP", `CREATE INDEX \u76EE\u6807\u8868\u4E0D\u5B58\u5728\uFF1A${tableName}`);
+        }
+        return { changes: 0 };
+      }
       if (/^INSERT\s+INTO/i.test(stmt)) return this.execInsert(stmt, params);
       if (/^UPDATE\s+/i.test(stmt)) return this.execUpdate(stmt, params);
       if (/^DELETE\s+FROM/i.test(stmt)) return this.execDelete(stmt, params);
@@ -5652,16 +6648,36 @@ self.onmessage = async (event) => {
       const valueBody = match[4].trim();
       const cursor = new ParamCursor(params);
       const table = this.ensureTable(tableName);
+      const { tuples, conflict } = splitInsertTuples(valueBody);
+      if (tuples.length === 0) throw new SimDbError("DB_UNSAFE_OP", "INSERT \u7F3A\u5C11 VALUES \u5143\u7EC4");
+      const conflictSpec = conflict === null ? null : parseConflictClause(
+        conflict,
+        cursor,
+        table.columns.filter((c) => c.primaryKey).map((c) => c.name)
+      );
       let inserted = 0;
-      for (const group of splitListItems(valueBody)) {
-        const inner = group.trim().replace(/^\(|\)$/g, "");
-        const values = splitListItems(inner).map(
+      for (const tuple of tuples) {
+        const values = splitListItems(tuple).map(
           (item) => item.trim() === "?" ? cursor.take() : stripQuotes(item)
         );
         const row = {};
         cols.forEach((col, i) => {
           row[col] = values[i] ?? null;
         });
+        if (conflictSpec !== null) {
+          const existing = table.rows.find(
+            (r) => conflictSpec.cols.every((c) => r[c] === row[c])
+          );
+          if (existing !== void 0) {
+            const oldRow = { ...existing };
+            for (const set of conflictSpec.sets) {
+              existing[set.col] = resolveSetValue(set.value, oldRow, row);
+            }
+            inserted += 1;
+            void this.persist();
+            continue;
+          }
+        }
         this.applyAutoincrement(table, row);
         table.rows.push(row);
         inserted += 1;
@@ -5730,6 +6746,20 @@ self.onmessage = async (event) => {
         return project(this.catalog(), selectRaw);
       }
       const table = this.ensureTable(tableName);
+      let rows = table.rows;
+      const joins = parseLeftJoins(tail);
+      if (joins.length > 0) {
+        rows = table.rows.map((row) => {
+          const merged = { ...row };
+          for (const j of joins) {
+            const joined = this.tables[j.table]?.rows.find((jr) => jr[j.leftCol] === merged[j.rightCol]);
+            if (joined !== void 0) {
+              for (const [k, v] of Object.entries(joined)) merged[`${j.alias}.${k}`] = v;
+            }
+          }
+          return merged;
+        });
+      }
       const whereMatch = /\bWHERE\b/i.exec(tail);
       const orderMatch = /\bORDER\s+BY\b/i.exec(tail);
       const limitMatch = /\bLIMIT\b/i.exec(tail);
@@ -5738,7 +6768,6 @@ self.onmessage = async (event) => {
         whereMatch.index + whereMatch[0].length,
         indexAfter(whereMatch.index, [orderMatch, limitMatch, offsetMatch], tail)
       );
-      let rows = table.rows;
       if (whereRaw.trim().length > 0) {
         const clauses = parseWhereClauses(whereRaw, cursor);
         rows = rows.filter((row) => matchWhere(clauses, row));
@@ -5748,9 +6777,9 @@ self.onmessage = async (event) => {
           orderMatch.index + orderMatch[0].length,
           indexAfter(orderMatch.index, [limitMatch, offsetMatch], tail)
         );
-        const oc = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+(asc|desc)/i.exec(orderRaw);
+        const oc = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_.]*))\s+(asc|desc)/i.exec(orderRaw);
         if (oc !== null) {
-          const col = ident(oc[1]);
+          const col = unqualifyColumn(ident(oc[1]));
           const dir = oc[3].toLowerCase();
           rows = [...rows].toSorted((a, b) => {
             const av = a[col];
@@ -5795,6 +6824,15 @@ self.onmessage = async (event) => {
     const end = candidates.length === 0 ? -1 : Math.min(...candidates);
     return end === -1 ? tail.length : end;
   }
+  function parseSelectItem(raw) {
+    const t = raw.trim();
+    const as = /\s+AS\s+([A-Za-z_][A-Za-z0-9_]*)$/i.exec(t);
+    let name = as === null ? t : t.slice(0, as.index).trim();
+    if (unqualifyColumn(name) === "*") return { name: "", qualified: "", alias: "", star: true };
+    const qualified = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? ident(name) : "";
+    const plain = unqualifyColumn(ident(name));
+    return { name: plain, qualified, alias: as === null ? plain : ident(as[1] ?? ""), star: false };
+  }
   function project(rows, selectRaw) {
     if (/^count\s*\(\s*\*/i.test(selectRaw) || /^count\s*\(\s*1\)/i.test(selectRaw)) {
       const alias = selectRaw.match(/\bAS\s+([A-Za-z_][A-Za-z0-9_]*)/i)?.[1] ?? "n";
@@ -5805,10 +6843,21 @@ self.onmessage = async (event) => {
       return [{ [constMatch[2]]: Number(constMatch[1]) }];
     }
     if (selectRaw.trim() === "*") return rows;
-    const cols = selectRaw.split(",").map((s) => ident(s.trim()));
+    const items = selectRaw.split(",").map(parseSelectItem);
+    const valueOf = (row, item) => item.qualified !== "" && row[item.qualified] !== void 0 ? row[item.qualified] : row[item.name];
+    if (items.some((item) => item.star)) {
+      return rows.map((row) => {
+        const out = { ...row };
+        for (const item of items) {
+          if (item.star) continue;
+          out[item.alias] = valueOf(row, item);
+        }
+        return out;
+      });
+    }
     return rows.map((row) => {
       const out = {};
-      for (const col of cols) out[col] = row[col];
+      for (const item of items) out[item.alias] = valueOf(row, item);
       return out;
     });
   }
@@ -5881,6 +6930,19 @@ self.onmessage = async (event) => {
     }
     return path;
   }
+  function assertStoragePrefix(prefix) {
+    if (prefix !== void 0 && prefix !== "") {
+      const segments = prefix.split("/");
+      if (prefix.startsWith("/") || /[\\]/.test(prefix) || segments.some((segment) => segment === "..")) {
+        throw new StorageError(
+          400,
+          STORAGE_CODES.invalidPath,
+          `\u975E\u6CD5\u524D\u7F00 "${prefix}"\uFF08\u7981\u6B62 / \u5F00\u5934\u3001\u53CD\u659C\u6760\u6216 .. \u7A7F\u8D8A\uFF09`
+        );
+      }
+    }
+    return prefix ?? "";
+  }
 
   // ../runtime/src/storage/hmac-sha256.ts
   var K = new Uint32Array([
@@ -6200,16 +7262,7 @@ self.onmessage = async (event) => {
         await saveBucket(bucket);
       },
       async list(_projectId, prefix) {
-        if (prefix !== void 0 && prefix !== "") {
-          const segments = prefix.split("/");
-          if (prefix.startsWith("/") || /[\\]/.test(prefix) || segments.some((segment) => segment === "..")) {
-            throw new StorageError(
-              400,
-              STORAGE_CODES.invalidPath,
-              `\u975E\u6CD5\u524D\u7F00 "${prefix}"\uFF08\u7981\u6B62 / \u5F00\u5934\u3001\u53CD\u659C\u6760\u6216 .. \u7A7F\u8D8A\uFF09`
-            );
-          }
-        }
+        assertStoragePrefix(prefix);
         const bucket = await loadBucket();
         return Object.values(bucket).filter((object) => prefix === void 0 || object.path.startsWith(prefix)).map(toMeta).toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
       },
@@ -6596,6 +7649,19 @@ self.onmessage = async (event) => {
     };
   }
 
+  // ../runtime/src/functions/runtime/rpc-wire.ts
+  function wireRpcResponses(port, pending) {
+    port.on?.((message) => {
+      const reply = message;
+      if (reply?.type !== "rpc-response" || typeof reply.id !== "number") return;
+      const entry = pending.get(reply.id);
+      if (entry === void 0) return;
+      pending.delete(reply.id);
+      if (reply.ok === true) entry.resolve(reply.result);
+      else entry.reject(new Error(reply.error ?? "RPC \u80FD\u529B\u8C03\u7528\u5931\u8D25"));
+    });
+  }
+
   // src/sim/ctx.ts
   function createLocalPort(handler) {
     const listeners = [];
@@ -6625,17 +7691,6 @@ self.onmessage = async (event) => {
       }
     };
   }
-  function wireRpcResponses(port, pending) {
-    port.on((message) => {
-      const reply = message;
-      if (reply?.type !== "rpc-response" || typeof reply.id !== "number") return;
-      const entry = pending.get(reply.id);
-      if (entry === void 0) return;
-      pending.delete(reply.id);
-      if (reply.ok === true) entry.resolve(reply.result);
-      else entry.reject(new Error(reply.error ?? "RPC \u80FD\u529B\u8C03\u7528\u5931\u8D25"));
-    });
-  }
   function createFlatRpcClient(handler) {
     return new Proxy(
       {},
@@ -6849,6 +7904,27 @@ self.onmessage = async (event) => {
     return { run };
   }
 
+  // ../runtime/src/sim/merge.ts
+  function mergeBundles(bundles) {
+    const capabilities = [];
+    const byName = /* @__PURE__ */ new Map();
+    for (const bundle of bundles) {
+      for (const cap of bundle.capabilities) {
+        const existing = byName.get(cap.name);
+        if (existing !== void 0) capabilities.splice(capabilities.indexOf(existing), 1);
+        byName.set(cap.name, cap);
+        capabilities.push(cap);
+      }
+    }
+    const rpcHandlers = {};
+    for (const bundle of bundles) {
+      for (const [name, handler] of Object.entries(bundle.rpcHandlers)) {
+        rpcHandlers[name] = handler;
+      }
+    }
+    return { capabilities, rpcHandlers };
+  }
+
   // ../runtime/src/database/sdk/kv.ts
   var KV_TABLE = "_adep_kv";
   var KV_RPC = {
@@ -6950,25 +8026,6 @@ self.onmessage = async (event) => {
   }
 
   // src/sim/runtime.ts
-  function mergeBundles(bundles) {
-    const capabilities = [];
-    const byName = /* @__PURE__ */ new Map();
-    for (const bundle of bundles) {
-      for (const cap of bundle.capabilities) {
-        const existing = byName.get(cap.name);
-        if (existing !== void 0) capabilities.splice(capabilities.indexOf(existing), 1);
-        byName.set(cap.name, cap);
-        capabilities.push(cap);
-      }
-    }
-    const rpcHandlers = {};
-    for (const bundle of bundles) {
-      for (const [name, handler] of Object.entries(bundle.rpcHandlers)) {
-        rpcHandlers[name] = handler;
-      }
-    }
-    return { capabilities, rpcHandlers };
-  }
   async function createBrowserSimRuntime(options) {
     const kv = options.kv ?? pickDefaultSimKv();
     const db = createBrowserSimDb({ projectId: options.projectId, kv });
@@ -6999,5 +8056,6 @@ self.onmessage = async (event) => {
 
   // src/index.ts
   init_function_fetch_proxy();
+  init_console_relay();
   return __toCommonJS(index_exports);
 })();