@open-wxa/wxa-runner-core 0.7.0 → 0.8.0

package/dist/runtime/host.js

@@ -1,5 +1,96 @@
 "use strict";
 (() => {
+  // src/runtime/host/ConsoleForwarder.ts
+  var DEDUPE_MS = 1e3;
+  var MAX_ARG_LENGTH = 1e3;
+  var MAX_TEXT_LENGTH = 8e3;
+  var LAYERS = { service: "\u903B\u8F91\u5C42", webview: "\u6E32\u67D3\u5C42" };
+  var MINI_PROGRAM_ERROR = /^(\(in promise\) )?MiniProgramError\n/;
+  var MODULE_URL = /\bhttps?:\/\/[^/\s]+\/__wxa__\/module\/([^?\s)]+?)(?:\?[^:\s)]*)?:(\d+):(\d+)/;
+  var ConsoleForwarder = class {
+    /** @param pageOf 出错的页面路径，不知道时返回 undefined */
+    constructor(mode, send, pageOf) {
+      this.mode = mode;
+      this.send = send;
+      this.pageOf = pageOf;
+      this.recentErrors = /* @__PURE__ */ new Map();
+    }
+    /** 运行时错误：全局 error、未处理的 Promise 拒绝、基础库捕获的业务代码错误 */
+    error(kind, webviewId, message, stack) {
+      const frames = businessFrames(stack);
+      if (!this.mode || this.isRepeated(`${kind}:${webviewId}:${message}
+${frames}`)) return;
+      this.post("error", `${this.origin(kind, webviewId)}\u62A5\u9519\uFF1A${message}${frames ? `
+${frames}` : ""}`);
+    }
+    /** 运行时自己的提醒，如调用了未实现的 wx API */
+    warn(text) {
+      if (this.mode) this.post("warn", text);
+    }
+    /** iframe 里的 console.warn / console.error；基础库捕获业务代码错误后打印的 console.error 按报错转发 */
+    console(kind, webviewId, level, args) {
+      const thrown = level === "error" ? miniProgramError(args[0]) : null;
+      if (thrown) {
+        this.error(kind, webviewId, thrown.message, thrown.stack);
+      } else if (this.mode === "all") {
+        this.post(level, `${this.origin(kind, webviewId)} console.${level}\uFF1A${args.map(formatArg).join(" ")}`);
+      }
+    }
+    post(level, text) {
+      this.send({ type: "console", level, text: text.length > MAX_TEXT_LENGTH ? `${text.slice(0, MAX_TEXT_LENGTH)}\u2026` : text });
+    }
+    origin(kind, webviewId) {
+      const page = this.pageOf(kind, webviewId);
+      return page ? `${LAYERS[kind]}\uFF08${page}\uFF09` : LAYERS[kind];
+    }
+    /** @param key 来源、错误信息和业务代码的帧：两路报来的同一个错误相同，不同位置抛出的同名错误不同 */
+    isRepeated(key) {
+      const now = Date.now();
+      for (const [recent, time] of this.recentErrors) {
+        if (now - time >= DEDUPE_MS) this.recentErrors.delete(recent);
+      }
+      if (this.recentErrors.has(key)) return true;
+      this.recentErrors.set(key, now);
+      return false;
+    }
+  };
+  function isErrorLike(value) {
+    return typeof value === "object" && value !== null && typeof value.message === "string";
+  }
+  function miniProgramError(value) {
+    if (isErrorLike(value) && MINI_PROGRAM_ERROR.test(value.message)) {
+      return { message: value.message.replace(MINI_PROGRAM_ERROR, ""), stack: value.stack };
+    }
+    if (typeof value === "string" && MINI_PROGRAM_ERROR.test(value)) {
+      const text = value.replace(MINI_PROGRAM_ERROR, "");
+      const firstFrame2 = text.search(/^\s*at /m);
+      const head = (firstFrame2 < 0 ? text : text.slice(0, firstFrame2)).replace(/\n$/, "");
+      const message = /^([\s\S]*)\n[^\n]*?: \1$/.exec(head)?.[1] ?? head;
+      return { message, stack: firstFrame2 < 0 ? void 0 : text.slice(firstFrame2) };
+    }
+    return null;
+  }
+  function businessFrames(stack) {
+    return (stack || "").split("\n").filter((line) => /^\s*at /.test(line) && MODULE_URL.test(line)).map((line) => `    ${line.trim().replace(MODULE_URL, "$1:$2:$3")}`).join("\n");
+  }
+  function formatArg(arg) {
+    if (typeof arg === "string") return truncate(arg);
+    if (isErrorLike(arg)) {
+      const frames = businessFrames(arg.stack);
+      return truncate(`${arg.name || "Error"}: ${arg.message}`) + (frames ? `
+${frames}` : "");
+    }
+    try {
+      const json = JSON.stringify(arg);
+      if (json !== void 0) return truncate(json);
+    } catch {
+    }
+    return truncate(String(arg));
+  }
+  function truncate(text) {
+    return text.length > MAX_ARG_LENGTH ? `${text.slice(0, MAX_ARG_LENGTH)}\u2026` : text;
+  }
+
   // src/runtime/host/api/registry.ts
   var SILENT_APIS = /* @__PURE__ */ new Set([
     "reportKeyValue",
@@ -205,154 +296,103 @@
     };
   }
 
-  // src/runtime/host/api/tempFiles.ts
-  var TEMP_DIR = "/__wxa__/tmp";
-  async function saveTempFile(data, type) {
-    const res = await fetch(`${TEMP_DIR}?type=${encodeURIComponent(type)}`, { method: "POST", body: data });
-    if (!res.ok) throw new Error(await res.text());
-    const { url } = await res.json();
-    return url;
-  }
-  function tempFileRootPath(url) {
-    const prefix = `${location.origin}${TEMP_DIR}/`;
-    return url.startsWith(prefix) ? url.slice(location.origin.length) : url;
-  }
-  function tempFileType(name, mimeType, fallback) {
-    const fromName = /\.([a-z\d]+)$/i.exec(name)?.[1];
-    const fromType = /^[a-z]+\/([a-z\d]+)\s*(;|$)/i.exec(mimeType)?.[1];
-    return (fromName || fromType || fallback).toLowerCase();
-  }
-  function isTempFile(filePath) {
-    return typeof filePath === "string" && filePath.startsWith(`${location.origin}${TEMP_DIR}/`);
-  }
-  async function tempFileSize(url) {
-    const res = await fetch(url, { method: "HEAD" });
-    return res.ok ? Number(res.headers.get("content-length")) : null;
-  }
-  async function removeTempFile(url) {
-    await fetch(url, { method: "DELETE" });
+  // src/runtime/fileSession.ts
+  var KEY = "__wxa_file_session__";
+  function fileSession() {
+    let session = localStorage.getItem(KEY);
+    if (!session) {
+      session = crypto.randomUUID();
+      localStorage.setItem(KEY, session);
+    }
+    return session;
   }
 
   // src/runtime/host/api/fs.ts
-  var DIR_MODE = 16877;
-  var FILE_MODE = 33188;
-  var MemoryFileSystem = class {
-    constructor() {
-      this.nodes = /* @__PURE__ */ new Map([["/", { dir: true, data: "", mtime: Date.now() }]]);
-    }
-    normalize(filePath) {
-      const stripped = String(filePath || "").replace(/^[a-z]+:\/\/[^/]*/i, "");
-      const parts = [];
-      for (const part of stripped.split("/")) {
-        if (!part || part === ".") continue;
-        if (part === "..") parts.pop();
-        else parts.push(part);
-      }
-      return "/" + parts.join("/");
-    }
-    stat(filePath) {
-      return this.nodes.get(this.normalize(filePath));
-    }
-    mkdir(dirPath, recursive = false) {
-      const target = this.normalize(dirPath);
-      if (this.nodes.has(target)) throw new Error(`file already exists ${dirPath}`);
-      const parent = target.slice(0, target.lastIndexOf("/")) || "/";
-      if (!this.nodes.get(parent)?.dir) {
-        if (!recursive) throw new Error(`no such file or directory ${dirPath}`);
-        this.mkdir(parent, true);
-      }
-      this.nodes.set(target, { dir: true, data: "", mtime: Date.now() });
-    }
-    write(filePath, data, append = false) {
-      const target = this.normalize(filePath);
-      const parent = target.slice(0, target.lastIndexOf("/")) || "/";
-      if (!this.nodes.get(parent)?.dir) throw new Error(`no such file or directory ${filePath}`);
-      const existing = this.nodes.get(target);
-      if (existing?.dir) throw new Error(`illegal operation on a directory ${filePath}`);
-      this.nodes.set(target, { dir: false, data: append && existing ? existing.data + data : data, mtime: Date.now() });
-    }
-    read(filePath) {
-      const node = this.stat(filePath);
-      if (!node) throw new Error(`no such file or directory, open ${filePath}`);
-      if (node.dir) throw new Error(`illegal operation on a directory ${filePath}`);
-      return node.data;
-    }
-    readdir(dirPath) {
-      const target = this.normalize(dirPath);
-      if (!this.nodes.get(target)?.dir) throw new Error(`no such file or directory ${dirPath}`);
-      const prefix = target === "/" ? "/" : target + "/";
-      return [...this.nodes.keys()].filter((key) => key.startsWith(prefix) && key !== target && !key.slice(prefix.length).includes("/")).map((key) => key.slice(prefix.length));
-    }
-    remove(filePath, options) {
-      const target = this.normalize(filePath);
-      const node = this.nodes.get(target);
-      if (!node) throw new Error(`no such file or directory ${filePath}`);
-      if (node.dir !== options.dir) throw new Error(options.dir ? `not a directory ${filePath}` : `operation not permitted ${filePath}`);
-      if (node.dir) {
-        const children = this.readdir(target);
-        if (children.length && !options.recursive) throw new Error(`directory not empty ${filePath}`);
-        for (const key of [...this.nodes.keys()]) if (key.startsWith(target + "/")) this.nodes.delete(key);
-      }
-      this.nodes.delete(target);
-    }
-  };
-  function createFileSystemApis() {
-    const fs = new MemoryFileSystem();
-    const guard = (api, action) => {
-      try {
-        return ok(api, action() || {});
-      } catch (error) {
-        return fail(api, error.message);
-      }
-    };
-    const statResult = (node) => {
-      const stats = {
-        mode: node.dir ? DIR_MODE : FILE_MODE,
-        size: node.data.length,
-        lastAccessedTime: Math.floor(node.mtime / 1e3),
-        lastModifiedTime: Math.floor(node.mtime / 1e3)
-      };
-      return { stats, ...stats };
-    };
-    const readMemoryFile = (args, { api }) => guard(api, () => ({ data: fs.read(args.filePath) }));
-    const apis = {
-      access: (args, { api }) => fs.stat(args.path) ? ok(api) : fail(api, `no such file or directory ${args.path}`),
-      stat: (args, { api }) => {
-        const node = fs.stat(args.path);
-        return node ? ok(api, statResult(node)) : fail(api, `no such file or directory ${args.path}`);
-      },
-      mkdir: (args, { api }) => guard(api, () => fs.mkdir(args.dirPath, !!args.recursive)),
-      writeFile: (args, { api }) => guard(api, () => fs.write(args.filePath, String(args.data ?? ""))),
-      appendFile: (args, { api }) => guard(api, () => fs.write(args.filePath, String(args.data ?? ""), true)),
-      readdir: (args, { api }) => guard(api, () => ({ files: fs.readdir(args.dirPath) })),
-      unlink: (args, { api }) => guard(api, () => fs.remove(args.filePath, { dir: false })),
-      rmdir: (args, { api }) => guard(api, () => fs.remove(args.dirPath, { dir: true, recursive: !!args.recursive })),
-      getFileInfo: (args, { api }) => {
-        if (isTempFile(args.filePath)) {
-          return tempFileSize(args.filePath).then((size) => size === null ? fail(api, "file not exist") : ok(api, { size }));
+  function requestFile(operation, args, sync) {
+    const url = "/__wxa__/fs/" + fileSession();
+    const body = JSON.stringify({ operation, args });
+    if (!sync)
+      return fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body
+      }).then(async (response) => fileResult(response.status, await response.text()));
+    const request = new XMLHttpRequest();
+    request.open("POST", url, false);
+    request.setRequestHeader("content-type", "application/json");
+    request.send(body);
+    return fileResult(request.status, request.responseText);
+  }
+  function fileResult(status, text) {
+    if (status !== 200) throw new Error(`filesystem HTTP ${status}`);
+    const { result, error } = JSON.parse(text);
+    if (error) throw new Error(error);
+    return result;
+  }
+  function createFileSystemApis(request = requestFile) {
+    const apis = {};
+    for (const operation of [
+      "access",
+      "stat",
+      "mkdir",
+      "writeFile",
+      "appendFile",
+      "readdir",
+      "unlink",
+      "rmdir",
+      "getFileInfo",
+      "copyFile",
+      "readFile"
+    ]) {
+      const handler = (args, { api }) => {
+        try {
+          const input = { ...args };
+          const isBuffer = Object.prototype.toString.call(input.data) === "[object ArrayBuffer]";
+          if (isBuffer || ArrayBuffer.isView(input.data)) {
+            const view = isBuffer ? new Uint8Array(input.data) : new Uint8Array(input.data.buffer, input.data.byteOffset, input.data.byteLength);
+            let binary = "";
+            for (let offset = 0; offset < view.length; offset += 32768) {
+              binary += String.fromCharCode(...view.subarray(offset, offset + 32768));
+            }
+            input.data = btoa(binary);
+            input.binary = true;
+          }
+          const decode = (result2) => {
+            if (result2.binary) {
+              result2.data = Uint8Array.from(atob(result2.data), (character) => character.charCodeAt(0)).buffer;
+              delete result2.binary;
+            }
+            return ok(api, result2);
+          };
+          const result = request(operation, input, api.endsWith("Sync"));
+          return result instanceof Promise ? result.then(decode, (error) => fail(api, error.message)) : decode(result);
+        } catch (error) {
+          return fail(api, error.message);
         }
-        const node = fs.stat(args.filePath);
-        return node ? ok(api, { size: node.data.length }) : fail(api, "file not exist");
-      }
-    };
-    for (const name of Object.keys(apis)) apis[name + "Sync"] = apis[name];
-    return {
-      ...apis,
-      fs_appendFile: apis.appendFile,
-      // 不带协议的是代码包里的文件，要向开发服务器取；readFileSync 同步返回不了，只读内存文件系统。
-      // 内存文件系统的路径去掉了协议，不能先在里面找：用户目录下的同名文件会顶替代码包里的
-      readFile: (args, context) => /^[a-z]+:\/\//i.test(String(args.filePath)) ? readMemoryFile(args, context) : readPackageFile(fs.normalize(args.filePath), args.encoding).then(
-        (data) => ok(context.api, { data }),
-        (error) => fail(context.api, error.message)
-      ),
-      readFileSync: readMemoryFile
-    };
+      };
+      apis[operation] = handler;
+      apis[operation + "Sync"] = handler;
+      apis["fs_" + operation] = handler;
+      apis["fs_" + operation + "Sync"] = handler;
+    }
+    const readUserFile = apis.readFile;
+    apis.readFile = (args, context) => /^[a-z]+:\/\//i.test(String(args.filePath)) || /^\/__wxa__\/(tmp|usr)\//.test(String(args.filePath)) ? readUserFile(args, context) : readPackageFile(args.filePath, args.encoding).then(
+      (data) => ok(context.api, { data }),
+      (error) => fail(context.api, error.message)
+    );
+    apis.fs_readFile = apis.readFile;
+    return apis;
   }
   async function readPackageFile(filePath, encoding) {
     if (encoding !== void 0 && encoding !== "utf8" && encoding !== "utf-8") {
       throw new Error(`\u8BFB\u53D6\u4EE3\u7801\u5305\u91CC\u7684\u6587\u4EF6\u53EA\u652F\u6301 utf8 \u7F16\u7801\uFF0C\u6216\u4E0D\u6307\u5B9A\u7F16\u7801\u5F97\u5230 ArrayBuffer\uFF0C\u4E0D\u652F\u6301 ${encoding}`);
     }
-    const response = await fetch(filePath.split("/").map(encodeURIComponent).join("/"));
+    const parts = [];
+    for (const part of String(filePath).split("/")) {
+      if (part === "..") parts.pop();
+      else if (part && part !== ".") parts.push(part);
+    }
+    const response = await fetch("/" + parts.map(encodeURIComponent).join("/"));
     if (!response.ok) throw new Error(`no such file or directory, open ${filePath}`);
     return encoding ? response.text() : response.arrayBuffer();
   }
@@ -429,6 +469,34 @@
     }
   };
 
+  // src/runtime/host/api/tempFiles.ts
+  var TEMP_DIR = "/__wxa__/tmp";
+  async function saveTempFile(data, type) {
+    const res = await fetch(`${TEMP_DIR}/${fileSession()}?type=${encodeURIComponent(type)}`, { method: "POST", body: data });
+    if (!res.ok) throw new Error(await res.text());
+    const { url } = await res.json();
+    return url;
+  }
+  function tempFileRootPath(url) {
+    const prefix = `${location.origin}${TEMP_DIR}/`;
+    return url.startsWith(prefix) ? url.slice(location.origin.length) : url;
+  }
+  function tempFileType(name, mimeType, fallback) {
+    const fromName = /\.([a-z\d]+)$/i.exec(name)?.[1];
+    const fromType = /^[a-z]+\/([a-z\d]+)\s*(;|$)/i.exec(mimeType)?.[1];
+    return (fromName || fromType || fallback).toLowerCase();
+  }
+  function isTempFile(filePath) {
+    return typeof filePath === "string" && filePath.startsWith(`${location.origin}${TEMP_DIR}/`);
+  }
+  async function tempFileSize(url) {
+    const res = await fetch(url, { method: "HEAD" });
+    return res.ok ? Number(res.headers.get("content-length")) : null;
+  }
+  async function removeTempFile(url) {
+    await fetch(url, { method: "DELETE" });
+  }
+
   // src/runtime/host/api/media.ts
   var SOURCES = ["camera", "album"];
   var SOURCE_LABELS = { camera: "\u62CD\u6444", album: "\u4ECE\u624B\u673A\u76F8\u518C\u9009\u62E9" };
@@ -630,6 +698,32 @@
     return fail(api, "not available in wxa-runner");
   }
 
+  // src/runtime/networkPanel.ts
+  var PROXY_PREFIX = "/__wxa__/proxy/";
+  var MOCK_PREFIX = "/__wxa__/mock/";
+  var MOCK_ID_HEADER = "x-wxa-mock-id";
+  function toServerPath(prefix, url) {
+    let target;
+    try {
+      target = new URL(url);
+    } catch {
+      return null;
+    }
+    if (target.protocol !== "http:" && target.protocol !== "https:") return null;
+    return `${prefix}${target.protocol.slice(0, -1)}/${target.host}${target.pathname}${target.search}`;
+  }
+  function toHeaders(header) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(header)) {
+      if (value === void 0 || value === null) continue;
+      try {
+        headers.set(name, String(value));
+      } catch {
+      }
+    }
+    return headers;
+  }
+
   // src/runtime/host/api/network.ts
   var RequestLog = class {
     constructor(limit = 1e3) {
@@ -676,8 +770,9 @@
       options.onRequest?.({ ...request, header: { ...request.header }, routedBy: route ? route.pattern : null });
       const requestTaskId = startTask(args, async (signal, id) => {
         try {
-          const mocked = route && await route.respond(signal);
-          const res = mocked ? { statusCode: mocked.statusCode, header: mocked.header, cookies: [], response: new Response(mocked.body) } : await proxyFetch(request.url, { method: request.method, header: args.header, body: args.data, signal });
+          const mocked = route?.respond(signal);
+          if (mocked) options.onMocked?.(request, mocked, signal);
+          const res = mocked ? await mocked.then(({ statusCode, header, body }) => ({ statusCode, header, cookies: [], response: new Response(body) })) : await proxyFetch(request.url, { method: request.method, header: args.header, body: args.data, signal });
           emit("onRequestTaskStateChange", {
             requestTaskId: id,
             state: "headersReceived",
@@ -685,7 +780,36 @@
             statusCode: res.statusCode,
             cookies: res.cookies
           });
-          const data = args.responseType === "arraybuffer" ? await res.response.arrayBuffer() : await res.response.text();
+          let data;
+          if (args.enableChunked && res.response.body) {
+            const reader = res.response.body.getReader();
+            const chunks = [];
+            let length = 0;
+            try {
+              for (; ; ) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                chunks.push(value);
+                length += value.byteLength;
+                emit("onRequestTaskStateChange", {
+                  requestTaskId: id,
+                  state: "chunked",
+                  data: value.slice().buffer
+                });
+              }
+            } finally {
+              reader.releaseLock();
+            }
+            const bytes = new Uint8Array(length);
+            let offset = 0;
+            for (const chunk of chunks) {
+              bytes.set(chunk, offset);
+              offset += chunk.byteLength;
+            }
+            data = args.responseType === "arraybuffer" ? bytes.buffer : new TextDecoder().decode(bytes);
+          } else {
+            data = args.responseType === "arraybuffer" ? await res.response.arrayBuffer() : await res.response.text();
+          }
           emit("onRequestTaskStateChange", {
             requestTaskId: id,
             state: "success",
@@ -733,7 +857,9 @@
     const createUploadTask = (args, { api }) => {
       const uploadTaskId = startTask(args, async (signal, id) => {
         try {
-          const file = await (await fetch(args.filePath)).blob();
+          const source = await fetch(args.filePath);
+          if (!source.ok) throw new Error(`file not exist ${args.filePath}`);
+          const file = await source.blob();
           const form = new FormData();
           for (const [key, value] of Object.entries(args.formData || {})) form.append(key, String(value));
           form.append(args.name || "file", file, String(args.filePath).split("/").pop() || "file");
@@ -824,12 +950,12 @@
     return args.responseType === "arraybuffer" && args.enableCache === true;
   }
   async function proxyFetch(url, init) {
-    if (!/^https?:\/\//i.test(url)) throw new Error(`invalid url "${url}"`);
-    const hasBody = init.body !== void 0 && init.body !== "" && !["GET", "HEAD"].includes(init.method);
-    const response = await fetch(`/__wxa__/proxy?url=${encodeURIComponent(url)}`, {
+    const path = toServerPath(PROXY_PREFIX, url);
+    if (!path) throw new Error(`invalid url "${url}"`);
+    const response = await fetch(path, {
       method: init.method,
       headers: { "x-wxa-headers": JSON.stringify(init.header || {}) },
-      body: hasBody ? init.body : void 0,
+      body: hasRequestBody(init.method, init.body) ? init.body : void 0,
       signal: init.signal
     });
     if (response.headers.get("x-wxa-proxy-error")) {
@@ -842,11 +968,56 @@
       response
     };
   }
+  function hasRequestBody(method, body) {
+    return body !== void 0 && body !== "" && !["GET", "HEAD"].includes(method);
+  }
   function reason(error) {
     if (error instanceof DOMException && error.name === "AbortError") return "abort";
     return error instanceof Error ? error.message : String(error);
   }
 
+  // src/runtime/host/api/mockMirror.ts
+  var SERVICE_WORKER_URL = "/__wxa__/runtime/sw.js";
+  var MockMirror = class {
+    constructor(serviceWorker) {
+      this.serviceWorker = serviceWorker;
+      /** 正在显示的请求，Service Worker 按 id 来要响应 */
+      this.replies = /* @__PURE__ */ new Map();
+      this.seq = 0;
+      serviceWorker.addEventListener("message", (event) => this.answer(event));
+      serviceWorker.startMessages();
+    }
+    /** response 失败（规则出错、请求被取消）时这一行显示为失败；signal abort 时显示为取消 */
+    show(request, response, signal) {
+      const path = toServerPath(MOCK_PREFIX, request.url);
+      if (!path || !this.serviceWorker.controller) return;
+      const id = String(++this.seq);
+      const cancelled = new Promise((resolve) => signal.addEventListener("abort", () => resolve(null), { once: true }));
+      this.replies.set(id, Promise.race([response.catch(() => null), cancelled]));
+      const headers = toHeaders(request.header);
+      headers.set(MOCK_ID_HEADER, id);
+      fetch(path, {
+        method: request.method,
+        headers,
+        body: hasRequestBody(request.method, request.data) ? request.data : void 0,
+        // 拦截规则给出 3xx 时只显示这个响应：跟随 Location 会真的发出请求，小程序那边也不跟随
+        redirect: "manual",
+        signal
+      }).catch(() => void 0).finally(() => this.replies.delete(id));
+    }
+    answer(event) {
+      const query = event.data;
+      const port = event.ports[0];
+      if (query?.type !== "wxa-mock-response" || !port) return;
+      (this.replies.get(query.id) ?? Promise.resolve(null)).then((reply) => port.postMessage(reply));
+    }
+  };
+  function installMockMirror() {
+    if (navigator.webdriver || !navigator.serviceWorker) return null;
+    navigator.serviceWorker.register(SERVICE_WORKER_URL, { scope: "/" }).catch((error) => console.warn("[wxa-runner] Service Worker \u6CE8\u518C\u5931\u8D25\uFF0C\u88AB\u62E6\u622A\u7684\u8BF7\u6C42\u4E0D\u4F1A\u663E\u793A\u5728 Network \u9762\u677F\u91CC", error));
+    return new MockMirror(navigator.serviceWorker);
+  }
+
   // src/runtime/host/api/picker.ts
   async function fetchRegionData(kind) {
     const res = await fetch(`/__wxa__/region/${kind}`);
@@ -2285,7 +2456,8 @@ html, body { margin: 0; height: 100%; background: radial-gradient(120% 80% at 50
   var BINDING_CANVAS_TYPES = /* @__PURE__ */ new Set(["2d", "webgl", "webgl2"]);
   var PROBE_TOP = -54321;
   var Host = class {
-    constructor(info, root) {
+    /** @param sendReport 把报错发给开发服务器打印到终端，见 AppInfo.forwardConsole */
+    constructor(info, root, sendReport = () => void 0) {
       this.info = info;
       this.errors = [];
       /** 小程序发出的 wx.request */
@@ -2293,6 +2465,8 @@ html, body { margin: 0; height: 100%; background: radial-gradient(120% 80% at 50
       this.api = new ApiRegistry((context) => this.reportUnimplemented(context));
       /** setup 和测试 API 声明的请求拦截 */
       this.routes = new RequestRoutes();
+      /** 把被拦截的请求显示在 Network 面板里 */
+      this.mockMirror = installMockMirror();
       this.mapOperations = new MapOperations((webviewId, event, data) => this.publishToPages(event, data, [webviewId]));
       this.service = null;
       /** 新版基础库的业务子上下文；旧版基础库业务代码直接在逻辑层 iframe 里 */
@@ -2309,6 +2483,11 @@ html, body { margin: 0; height: 100%; background: radial-gradient(120% 80% at 50
       /** 渲染层报来的 2d、webgl 画布，按编号记下所在页面和最近的位置，供 placeCanvas 认出逻辑层的画布元素 */
       this.canvases = /* @__PURE__ */ new Map();
       this.device = info.device;
+      this.forwarder = new ConsoleForwarder(
+        info.forwardConsole ?? false,
+        sendReport,
+        (kind, webviewId) => kind === "service" ? this.currentPage()?.path : this.pages.get(webviewId)?.path
+      );
       this.shell = new PhoneShell(root, info.device);
       this.tabPaths = new Set((info.wxConfig.tabBar?.list || []).map((item) => stripHtml(item.pagePath)));
       this.storage = new MiniProgramStorage(window.localStorage, info.appid);
@@ -2427,27 +2606,36 @@ html, body { margin: 0; height: 100%; background: radial-gradient(120% 80% at 50
     }
     reportError(kind, webviewId, error) {
       const err = typeof error?.message === "string" ? error : null;
-      this.errors.push({
+      const report = {
         kind,
         webviewId,
         message: err ? err.message : String(error),
         stack: typeof err?.stack === "string" ? err.stack : void 0
-      });
+      };
+      this.errors.push(report);
+      this.forwarder.error(kind, webviewId, report.message, report.stack);
+    }
+    get forwardConsole() {
+      return this.forwarder.mode;
+    }
+    reportConsole(kind, webviewId, level, args) {
+      this.forwarder.console(kind, webviewId, level, args);
     }
     /**
-     * 业务代码只运行在逻辑层，所以只记逻辑层调用、名字在 wx 上的 API，每个 API 一次。
+     * 只记录逻辑层的公开 wx API 和 FileSystemManager 方法，每个原生接口一次。
      * 其余是基础库内部调用的原生接口（如 getPermissionBytes），业务既没调用也 mock 不了
      */
     reportUnimplemented({ api, from }) {
+      if (from !== "service") return;
       const wx = this.serviceWindow()?.wx;
-      if (from !== "service" || typeof wx?.[api] !== "function") return;
+      const fileMethod = api.startsWith("fs_") ? api.slice(3) : api;
+      const isFileApi = typeof wx?.getFileSystemManager?.()[fileMethod] === "function";
+      if (typeof wx?.[api] !== "function" && !isFileApi) return;
       if (this.errors.some((error) => error.api === api)) return;
-      this.errors.push({
-        kind: "service",
-        webviewId: 0,
-        api,
-        message: `wx.${api} \u5C1A\u672A\u5B9E\u73B0\uFF0C\u8FD4\u56DE\u4E86\u9ED8\u8BA4\u6210\u529F\u3002\u53EF\u4EE5\u7528 mock \u8986\u76D6\uFF0C\u542F\u52A8\u9636\u6BB5\u5C31\u8C03\u7528\u7684\u8981\u5728 setup \u91CC mock`
-      });
+      const name = isFileApi ? `wx.getFileSystemManager().${fileMethod}` : `wx.${api}`;
+      const message = `${name} \u5C1A\u672A\u5B9E\u73B0\uFF0C\u8FD4\u56DE\u4E86\u9ED8\u8BA4\u6210\u529F\u3002\u53EF\u4EE5\u7528 mock \u8986\u76D6\uFF0C\u542F\u52A8\u9636\u6BB5\u5C31\u8C03\u7528\u7684\u8981\u5728 setup \u91CC mock`;
+      this.errors.push({ kind: "service", webviewId: 0, api, message });
+      this.forwarder.warn(message);
     }
     // ---------------------------------------------------------------------------
     // 路由
@@ -2681,7 +2869,8 @@ html, body { margin: 0; height: 100%; background: radial-gradient(120% 80% at 50
           emit: (event, data) => this.emitToService(event, data),
           defaultTimeout: () => this.info.wxConfig.networkTimeout?.request || 6e4,
           routes: this.routes,
-          onRequest: (request) => this.requests.add(request)
+          onRequest: (request) => this.requests.add(request),
+          onMocked: (request, response, signal) => this.mockMirror?.show(request, response, signal)
         }),
         ...createAudioApis({ emit: (event, data) => this.emitToService(event, data) }),
         ...createMapApis({ registry: this.api, operations: this.mapOperations }),
@@ -3124,14 +3313,14 @@ ${script}
     const root = document.getElementById("wxa-root");
     const info = await (await fetch("/__wxa__/app-info.json")).json();
     const restore = new PageStackRestore(info.appid);
-    connectDevServer(restore);
+    const sendReport = connectDevServer(restore);
     if (info.buildError) {
       new PhoneShell(root, info.device).showError(`\u7F16\u8BD1\u5931\u8D25
 
 ${info.buildError}`);
       return;
     }
-    const host = new Host(info, root);
+    const host = new Host(info, root, sendReport);
     window.__wxaHost = host;
     let markReady;
     const ready = new Promise((resolve) => {
@@ -3199,6 +3388,13 @@ ${message.message}`);
         else restore.reload(host);
       }
     };
+    const pending = [];
+    socket.onopen = () => pending.splice(0).forEach((data) => socket.send(data));
+    return (report) => {
+      const data = JSON.stringify(report);
+      if (socket.readyState === WebSocket.OPEN) socket.send(data);
+      else if (socket.readyState === WebSocket.CONNECTING) pending.push(data);
+    };
   }
   function currentHost() {
     return window.__wxaHost;