@dimina-kit/devtools 0.3.2-dev.20260525152421 → 0.3.2-dev.20260610082053

package/dist/preload/windows/main.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -11,15 +13,1936 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/preload/windows/main.ts
 var main_exports = {};
 module.exports = __toCommonJS(main_exports);
 var import_electron = require("electron");
+
+// src/shared/bridge-channels.ts
+var BRIDGE_CHANNELS = {
+  SPAWN: "dmb:spawn",
+  DISPOSE: "dmb:dispose",
+  PAGE_OPEN: "dmb:page:open",
+  PAGE_CLOSE: "dmb:page:close",
+  PAGE_LIFECYCLE: "dmb:page:lifecycle",
+  NAV_CALLBACK: "dmb:nav:callback",
+  SERVICE_INVOKE: "dmb:service:invoke",
+  SERVICE_PUBLISH: "dmb:service:publish",
+  RENDER_INVOKE: "dmb:render:invoke",
+  RENDER_PUBLISH: "dmb:render:publish",
+  TO_SERVICE: "dmb:to-service",
+  TO_RENDER: "dmb:to-render",
+  SIMULATOR_API: "dmb:simulator-api",
+  /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+  API_RESPONSE: "dmb:api:response",
+  /**
+   * simulator webview preload → main (sendSync): "is native-host mode on?".
+   * The guest preload can't read the launch `process.env`, so it asks main
+   * (which can) at install time. Reply is `e.returnValue = boolean`.
+   */
+  NATIVE_HOST_ENABLED: "dmb:native-host-enabled",
+  /**
+   * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+   * Main has no z-order concept — the active page lives only in DeviceShell's
+   * ShellState — so devtools panels / automation that must target "the current
+   * page's render webContents" resolve it through this signal. Fire-and-forget.
+   */
+  ACTIVE_PAGE: "dmb:active-page",
+  /**
+   * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+   * whenever it changes. Main has no stack of its own (it only learns the
+   * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+   * this to report multi-page stacks. Fire-and-forget.
+   */
+  PAGE_STACK: "dmb:page-stack"
+};
+var SIMULATOR_EVENTS = {
+  DOM_READY: "simulator:dom-ready",
+  NAV_BAR: "simulator:navigation-bar",
+  NAV_ACTION: "simulator:nav-action",
+  TAB_ACTION: "simulator:tab-action",
+  /** main → simulator: invoke a wx.* API on the simulator-resident MiniApp. */
+  API_CALL: "simulator:api-call",
+  /**
+   * main → simulator: the renderer toolbar picked a different device. Carries a
+   * NativeDeviceInfo; DeviceShell resizes the bezel + re-renders status bar /
+   * notch. The race-free INITIAL device rides NativeHostConfig.device (read
+   * synchronously at preload bridge-install); this event covers live changes.
+   */
+  DEVICE_CHANGE: "simulator:device-change"
+};
+
+// src/preload/runtime/main-api-runner.ts
+function makeBaseContext() {
+  const fakeRect = { width: 390, height: 844, x: 0, y: 0, top: 0, left: 0, right: 390, bottom: 844 };
+  const fakeRoot = {
+    getBoundingClientRect: () => fakeRect
+  };
+  return {
+    appId: "",
+    createCallbackFunction: () => void 0,
+    parent: {
+      el: {
+        querySelector: () => fakeRoot
+      },
+      getStatusBarRect: () => ({ height: 0 })
+    }
+  };
+}
+function runApiAsync(handlers, name, params) {
+  const handler = handlers[name];
+  if (!handler) {
+    return Promise.resolve({ ok: false, errMsg: `${name}:fail no handler` });
+  }
+  return new Promise((resolve) => {
+    let resolved = false;
+    const finish = (verdict) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(verdict);
+    };
+    const SUCCESS = /* @__PURE__ */ Symbol("main-cb-success");
+    const FAIL = /* @__PURE__ */ Symbol("main-cb-fail");
+    const COMPLETE = /* @__PURE__ */ Symbol("main-cb-complete");
+    const base = makeBaseContext();
+    const ctx = {
+      ...base,
+      createCallbackFunction(id) {
+        if (id === void 0 || id === null) return void 0;
+        return (...args) => {
+          const arg = args[0];
+          if (id === SUCCESS) {
+            finish({ ok: true, result: arg });
+          } else if (id === FAIL) {
+            const errMsg = arg && typeof arg === "object" && "errMsg" in arg ? String(arg.errMsg) : `${name}:fail`;
+            finish({ ok: false, errMsg, result: arg });
+          }
+        };
+      }
+    };
+    const userParams = params && typeof params === "object" && !Array.isArray(params) ? { ...params } : {};
+    const hadSuccess = userParams.success !== void 0 && userParams.success !== null;
+    const hadFail = userParams.fail !== void 0 && userParams.fail !== null;
+    const hadComplete = userParams.complete !== void 0 && userParams.complete !== null;
+    userParams.success = SUCCESS;
+    userParams.fail = FAIL;
+    if (hadComplete) userParams.complete = COMPLETE;
+    try {
+      const ret = handler.call(ctx, userParams);
+      if (ret && typeof ret.then === "function") {
+        Promise.resolve(ret).then(
+          (r) => finish({ ok: true, result: r }),
+          (err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            finish({ ok: false, errMsg: `${name}:fail ${msg}` });
+          }
+        );
+        return;
+      }
+      if (!hadSuccess && !hadFail) {
+        finish({ ok: true, result: ret });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      finish({ ok: false, errMsg: `${name}:fail ${msg}` });
+    }
+  });
+}
+
+// src/simulator/simulator-api-helpers.ts
+function bindCallbacks(ctx, opts) {
+  return {
+    onSuccess: ctx.createCallbackFunction(opts.success),
+    onFail: ctx.createCallbackFunction(opts.fail),
+    onComplete: ctx.createCallbackFunction(opts.complete)
+  };
+}
+function notSupportedApi(apiName) {
+  return function(opts = {}) {
+    const { onFail, onComplete } = bindCallbacks(this, opts);
+    onFail?.({ errMsg: `${apiName}:fail not supported in simulator` });
+    onComplete?.();
+  };
+}
+
+// src/simulator/simulator-api-storage.ts
+function setStorageSync({ key, data }) {
+  const storageKey = `${this.appId}_${key}`;
+  const dataString = typeof data === "object" ? JSON.stringify(data) : String(data);
+  localStorage.setItem(storageKey, dataString);
+}
+function getStorageSync({ key }) {
+  const storageKey = `${this.appId}_${key}`;
+  const raw = localStorage.getItem(storageKey);
+  if (raw === null) return { data: "" };
+  try {
+    return { data: JSON.parse(raw) };
+  } catch {
+    return { data: raw };
+  }
+}
+function removeStorageSync({ key }) {
+  const storageKey = `${this.appId}_${key}`;
+  localStorage.removeItem(storageKey);
+}
+function clearStorageSync() {
+  const prefix = `${this.appId}_`;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (k && k.startsWith(prefix)) keysToRemove.push(k);
+  }
+  keysToRemove.forEach((k) => localStorage.removeItem(k));
+}
+function getStorageInfoSync() {
+  const prefix = `${this.appId}_`;
+  const keys = [];
+  let currentSize = 0;
+  for (let i = 0; i < localStorage.length; i++) {
+    const fullKey = localStorage.key(i);
+    if (fullKey && fullKey.startsWith(prefix)) {
+      keys.push(fullKey.substring(prefix.length));
+      const item = localStorage.getItem(fullKey);
+      currentSize += item ? item.length * 2 : 0;
+    }
+  }
+  return { keys, currentSize, limitSize: 10 * 1024 * 1024 };
+}
+function setStorage({ key, data, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  try {
+    const storageKey = `${this.appId}_${key}`;
+    const dataString = typeof data === "object" ? JSON.stringify(data) : String(data);
+    localStorage.setItem(storageKey, dataString);
+    onSuccess?.({ errMsg: "setStorage:ok" });
+  } catch (e) {
+    onFail?.({ errMsg: `setStorage:fail ${e.message}` });
+  }
+  onComplete?.();
+}
+function getStorage({ key, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const storageKey = `${this.appId}_${key}`;
+  const raw = localStorage.getItem(storageKey);
+  if (raw === null) {
+    onFail?.({ errMsg: "getStorage:fail data not found" });
+  } else {
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      data = raw;
+    }
+    onSuccess?.({ data, errMsg: "getStorage:ok" });
+  }
+  onComplete?.();
+}
+function removeStorage({ key, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  try {
+    const storageKey = `${this.appId}_${key}`;
+    localStorage.removeItem(storageKey);
+    onSuccess?.({ errMsg: "removeStorage:ok" });
+  } catch (e) {
+    onFail?.({ errMsg: `removeStorage:fail ${e.message}` });
+  }
+  onComplete?.();
+}
+function clearStorage({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const prefix = `${this.appId}_`;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (k && k.startsWith(prefix)) keysToRemove.push(k);
+  }
+  keysToRemove.forEach((k) => localStorage.removeItem(k));
+  onSuccess?.({ errMsg: "clearStorage:ok" });
+  onComplete?.();
+}
+function getStorageInfo({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const prefix = `${this.appId}_`;
+  const keys = [];
+  let currentSize = 0;
+  for (let i = 0; i < localStorage.length; i++) {
+    const fullKey = localStorage.key(i);
+    if (fullKey && fullKey.startsWith(prefix)) {
+      keys.push(fullKey.substring(prefix.length));
+      const item = localStorage.getItem(fullKey);
+      currentSize += item ? item.length * 2 : 0;
+    }
+  }
+  onSuccess?.({ keys, currentSize, limitSize: 10 * 1024 * 1024, errMsg: "getStorageInfo:ok" });
+  onComplete?.();
+}
+
+// src/simulator/simulator-api-device.ts
+function hideKeyboard({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  if (document.activeElement && typeof document.activeElement.blur === "function") {
+    ;
+    document.activeElement.blur();
+  }
+  onSuccess?.({ errMsg: "hideKeyboard:ok" });
+  onComplete?.();
+}
+function adjustPosition({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  onSuccess?.({ errMsg: "adjustPosition:ok" });
+  onComplete?.();
+}
+function makePhoneCall({ phoneNumber, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  try {
+    window.open(`tel:${phoneNumber}`);
+    onSuccess?.({ errMsg: "makePhoneCall:ok" });
+  } catch (error) {
+    onFail?.({ errMsg: `makePhoneCall:fail ${error.message}` });
+  }
+  onComplete?.();
+}
+var chooseContact = notSupportedApi("chooseContact");
+var addPhoneContact = notSupportedApi("addPhoneContact");
+function vibrateShort({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  if (navigator.vibrate) navigator.vibrate(15);
+  onSuccess?.({ errMsg: "vibrateShort:ok" });
+  onComplete?.();
+}
+function vibrateLong({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  if (navigator.vibrate) navigator.vibrate(400);
+  onSuccess?.({ errMsg: "vibrateLong:ok" });
+  onComplete?.();
+}
+var scanCode = notSupportedApi("scanCode");
+
+// src/simulator/event-bridge.ts
+function bindDomEvents(target, eventMap, fire, buildPayload) {
+  const registered = [];
+  for (const [domName, miniName] of Object.entries(eventMap)) {
+    const listener = (domEvent) => {
+      fire(buildPayload(miniName, domEvent));
+    };
+    target.addEventListener(domName, listener);
+    registered.push([domName, listener]);
+  }
+  return () => {
+    for (const [domName, listener] of registered) {
+      target.removeEventListener(domName, listener);
+    }
+    registered.length = 0;
+  };
+}
+
+// src/simulator/temp-files.ts
+var tempFiles = /* @__PURE__ */ new Map();
+var activeSink = null;
+function cryptoRandomId() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function createTempFilePath(blob) {
+  const path2 = `difile://_tmp/${cryptoRandomId()}`;
+  tempFiles.set(path2, blob);
+  activeSink?.write(path2, blob);
+  return path2;
+}
+async function resolveTempFilePath(path2) {
+  const cached = tempFiles.get(path2);
+  if (cached) return cached;
+  const response = await fetch(path2);
+  if (!response.ok) {
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${path2}`);
+  }
+  const blob = await response.blob();
+  tempFiles.set(path2, blob);
+  return blob;
+}
+function getTempFileName(path2, blob, fallback = "file") {
+  const named = blob;
+  if (typeof named.name === "string" && named.name.trim()) {
+    return named.name;
+  }
+  try {
+    const url = new URL(path2, window.location.href);
+    const segment = url.pathname.split("/").filter(Boolean).pop();
+    if (segment) return decodeURIComponent(segment);
+  } catch {
+  }
+  return fallback;
+}
+
+// src/simulator/simulator-api-media.ts
+function chooseImage({ count = 9, sourceType, camera, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const normalizedCount = normalizeChooseMediaCount(count);
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = "image/*";
+  input.multiple = normalizedCount > 1;
+  if (normalizedSourceType.length === 1 && normalizedSourceType[0] === "camera") {
+    input.setAttribute("capture", camera === "front" ? "user" : "environment");
+  }
+  input.style.display = "none";
+  document.body.appendChild(input);
+  input.addEventListener("change", () => {
+    const files = Array.from(input.files || []).slice(0, normalizedCount);
+    if (files.length === 0) {
+      onFail?.({ errMsg: "chooseImage:fail cancel" });
+      onComplete?.();
+      input.remove();
+      return;
+    }
+    const tempFilePaths = files.map((f) => createTempFilePath(f));
+    const tempFiles2 = files.map((f, i) => ({ path: tempFilePaths[i], size: f.size }));
+    onSuccess?.({ tempFilePaths, tempFiles: tempFiles2, errMsg: "chooseImage:ok" });
+    onComplete?.();
+    input.remove();
+  });
+  input.click();
+}
+function previewImage({ urls, current, success, complete }) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  if (!urls || urls.length === 0) {
+    onComplete?.();
+    return;
+  }
+  const overlay = document.createElement("div");
+  overlay.style.cssText = "position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,.85);display:flex;align-items:center;justify-content:center;cursor:pointer;";
+  const img = document.createElement("img");
+  img.src = current || urls[0] || "";
+  img.style.cssText = "max-width:90%;max-height:90%;object-fit:contain;";
+  overlay.appendChild(img);
+  overlay.addEventListener("click", () => overlay.remove());
+  document.body.appendChild(overlay);
+  onSuccess?.({ errMsg: "previewImage:ok" });
+  onComplete?.();
+}
+function compressImage({ src, quality = 80, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const img = new Image();
+  img.crossOrigin = "anonymous";
+  img.onload = () => {
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = img.naturalWidth;
+      canvas.height = img.naturalHeight;
+      const ctx = canvas.getContext("2d");
+      ctx.drawImage(img, 0, 0);
+      canvas.toBlob(
+        (blob) => {
+          if (blob) {
+            const tempFilePath = createTempFilePath(blob);
+            onSuccess?.({ tempFilePath, errMsg: "compressImage:ok" });
+          } else {
+            onFail?.({ errMsg: "compressImage:fail compression error" });
+          }
+          onComplete?.();
+        },
+        "image/jpeg",
+        quality / 100
+      );
+    } catch (error) {
+      onFail?.({ errMsg: `compressImage:fail ${error.message}` });
+      onComplete?.();
+    }
+  };
+  img.onerror = () => {
+    onFail?.({ errMsg: "compressImage:fail image load error" });
+    onComplete?.();
+  };
+  img.src = src;
+}
+function saveImageToPhotosAlbum({ filePath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  try {
+    const a = document.createElement("a");
+    a.href = filePath;
+    a.download = "image";
+    a.click();
+    onSuccess?.({ errMsg: "saveImageToPhotosAlbum:ok" });
+  } catch (error) {
+    onFail?.({ errMsg: `saveImageToPhotosAlbum:fail ${error.message}` });
+  }
+  onComplete?.();
+}
+function getImageInfo({ src, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const img = new Image();
+  img.crossOrigin = "anonymous";
+  img.onload = () => {
+    onSuccess?.({
+      width: img.naturalWidth,
+      height: img.naturalHeight,
+      path: src,
+      orientation: "up",
+      type: "unknown",
+      errMsg: "getImageInfo:ok"
+    });
+    onComplete?.();
+  };
+  img.onerror = () => {
+    onFail?.({ errMsg: "getImageInfo:fail image load error" });
+    onComplete?.();
+  };
+  img.src = src;
+}
+var VIDEO_METADATA_TIMEOUT_MS = 5e3;
+var VIDEO_THUMBNAIL_TIMEOUT_MS = 500;
+function normalizeStringArray(value, fallback) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : fallback;
+}
+function normalizeChooseMediaCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 9;
+  return Math.max(1, Math.min(20, Math.floor(n)));
+}
+function getChooseMediaAccept(mediaType) {
+  const wantsMix = mediaType.includes("mix");
+  const wantsImage = wantsMix || mediaType.includes("image");
+  const wantsVideo = wantsMix || mediaType.includes("video");
+  if (wantsImage && wantsVideo) return "image/*,video/*";
+  return wantsVideo ? "video/*" : "image/*";
+}
+function getChooseMediaResultType(files) {
+  const types = new Set(files.map((file) => file.fileType));
+  if (types.size > 1) return "mix";
+  return files[0]?.fileType ?? "image";
+}
+function readImageMetadata(src) {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve({ width: img.naturalWidth || 0, height: img.naturalHeight || 0 });
+    img.onerror = () => resolve({ width: 0, height: 0 });
+    img.src = src;
+  });
+}
+function readVideoMetadata(src) {
+  return new Promise((resolve) => {
+    const video = document.createElement("video");
+    let settled = false;
+    let seekTimer;
+    const finish = (metadata) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (seekTimer) clearTimeout(seekTimer);
+      video.onloadedmetadata = null;
+      video.onseeked = null;
+      video.onerror = null;
+      video.removeAttribute("src");
+      video.load();
+      resolve(metadata);
+    };
+    const drawThumbnail = (width, height) => {
+      return new Promise((resolveThumb) => {
+        let resolved = false;
+        const done = (value) => {
+          if (resolved) return;
+          resolved = true;
+          resolveThumb(value);
+        };
+        let canvas;
+        try {
+          canvas = document.createElement("canvas");
+          canvas.width = width || 1;
+          canvas.height = height || 1;
+          const ctx = canvas.getContext("2d");
+          ctx?.drawImage(video, 0, 0, canvas.width, canvas.height);
+        } catch {
+          done("");
+          return;
+        }
+        const toDataUrlFallback = () => {
+          try {
+            done(canvas.toDataURL("image/jpeg", 0.8));
+          } catch {
+            done("");
+          }
+        };
+        const fallbackTimer = setTimeout(toDataUrlFallback, VIDEO_THUMBNAIL_TIMEOUT_MS);
+        try {
+          canvas.toBlob(
+            (blob) => {
+              clearTimeout(fallbackTimer);
+              if (settled || resolved) return;
+              if (blob) {
+                done(createTempFilePath(blob));
+              } else {
+                toDataUrlFallback();
+              }
+            },
+            "image/jpeg",
+            0.8
+          );
+        } catch {
+          clearTimeout(fallbackTimer);
+          toDataUrlFallback();
+        }
+      });
+    };
+    const timer = setTimeout(() => finish({ width: 0, height: 0, duration: 0, thumbTempFilePath: "" }), VIDEO_METADATA_TIMEOUT_MS);
+    video.preload = "metadata";
+    video.muted = true;
+    video.onloadedmetadata = () => {
+      const width = video.videoWidth || 0;
+      const height = video.videoHeight || 0;
+      const duration = Number.isFinite(video.duration) ? video.duration : 0;
+      const metadata = { width, height, duration, thumbTempFilePath: "" };
+      if (!width || !height || duration <= 0) {
+        finish(metadata);
+        return;
+      }
+      video.onseeked = async () => {
+        if (seekTimer) {
+          clearTimeout(seekTimer);
+          seekTimer = void 0;
+        }
+        const thumbTempFilePath = await drawThumbnail(width, height);
+        finish({ ...metadata, thumbTempFilePath });
+      };
+      seekTimer = setTimeout(() => finish(metadata), VIDEO_THUMBNAIL_TIMEOUT_MS);
+      try {
+        video.currentTime = Math.min(0.1, Math.max(0, duration - 0.01));
+      } catch {
+        finish(metadata);
+      }
+    };
+    video.onerror = () => finish({ width: 0, height: 0, duration: 0, thumbTempFilePath: "" });
+    video.src = src;
+  });
+}
+async function buildChooseMediaTempFile(file) {
+  const tempFilePath = createTempFilePath(file);
+  const fileType = file.type.startsWith("video") ? "video" : "image";
+  if (fileType === "video") {
+    const metadata2 = await readVideoMetadata(tempFilePath);
+    return {
+      tempFilePath,
+      size: file.size,
+      duration: metadata2.duration,
+      height: metadata2.height,
+      width: metadata2.width,
+      thumbTempFilePath: metadata2.thumbTempFilePath,
+      fileType,
+      originalFileObj: file
+    };
+  }
+  const metadata = await readImageMetadata(tempFilePath);
+  return {
+    tempFilePath,
+    size: file.size,
+    duration: 0,
+    height: metadata.height,
+    width: metadata.width,
+    thumbTempFilePath: "",
+    fileType,
+    originalFileObj: file
+  };
+}
+function chooseMedia({ count = 9, mediaType = ["image", "video"], sourceType = ["album", "camera"], camera = "back", success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const normalizedCount = normalizeChooseMediaCount(count);
+  const normalizedMediaType = normalizeStringArray(mediaType, ["image", "video"]);
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = getChooseMediaAccept(normalizedMediaType);
+  input.multiple = normalizedCount > 1;
+  if (normalizedSourceType.length === 1 && normalizedSourceType[0] === "camera") {
+    input.setAttribute("capture", camera === "front" ? "user" : "environment");
+  }
+  input.style.display = "none";
+  document.body.appendChild(input);
+  input.addEventListener("change", async () => {
+    const files = Array.from(input.files || []).slice(0, normalizedCount);
+    if (files.length === 0) {
+      onFail?.({ errMsg: "chooseMedia:fail cancel" });
+      onComplete?.();
+      input.remove();
+      return;
+    }
+    try {
+      const tempFiles2 = await Promise.all(files.map(buildChooseMediaTempFile));
+      onSuccess?.({
+        tempFiles: tempFiles2,
+        type: getChooseMediaResultType(tempFiles2),
+        failedCount: 0,
+        errMsg: "chooseMedia:ok"
+      });
+    } catch (error) {
+      onFail?.({ errMsg: `chooseMedia:fail ${error.message}` });
+    } finally {
+      onComplete?.();
+      input.remove();
+    }
+  });
+  input.click();
+}
+function chooseVideo({ sourceType, camera, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = "video/*";
+  if (normalizedSourceType.length === 1 && normalizedSourceType[0] === "camera") {
+    input.setAttribute("capture", camera === "front" ? "user" : "environment");
+  }
+  input.style.display = "none";
+  document.body.appendChild(input);
+  input.addEventListener("change", async () => {
+    const files = Array.from(input.files || []);
+    if (files.length === 0) {
+      onFail?.({ errMsg: "chooseVideo:fail cancel" });
+      onComplete?.();
+      input.remove();
+      return;
+    }
+    const file = files[0];
+    const tempFilePath = createTempFilePath(file);
+    const metadata = await readVideoMetadata(tempFilePath);
+    onSuccess?.({
+      tempFilePath,
+      duration: metadata.duration,
+      size: file.size,
+      width: metadata.width,
+      height: metadata.height,
+      errMsg: "chooseVideo:ok"
+    });
+    onComplete?.();
+    input.remove();
+  });
+  input.click();
+}
+var AUDIO_EVENT_MAP = {
+  play: "play",
+  pause: "pause",
+  ended: "ended",
+  error: "error",
+  timeupdate: "timeUpdate",
+  waiting: "waiting",
+  seeking: "seeking",
+  seeked: "seeked",
+  canplay: "canplay"
+};
+var _newAudioInstances = /* @__PURE__ */ new Map();
+var _audioEventDisposers = /* @__PURE__ */ new Map();
+var _audioFire = /* @__PURE__ */ new Map();
+function audioSnapshot(audio, event) {
+  return {
+    event,
+    currentTime: audio.currentTime || 0,
+    duration: Number.isFinite(audio.duration) ? audio.duration : 0,
+    buffered: audio.buffered.length ? audio.buffered.end(audio.buffered.length - 1) : 0,
+    paused: audio.paused
+  };
+}
+function audioCreate({ audioId }) {
+  _newAudioInstances.set(audioId, new Audio());
+}
+function audioListen({ audioId, success }) {
+  const audio = _newAudioInstances.get(audioId);
+  const fire = this.createCallbackFunction(success);
+  if (!audio || !fire) return;
+  _audioFire.set(audioId, fire);
+  _audioEventDisposers.get(audioId)?.();
+  const dispose = bindDomEvents(
+    audio,
+    AUDIO_EVENT_MAP,
+    fire,
+    (event) => audioSnapshot(audio, event)
+  );
+  _audioEventDisposers.set(audioId, dispose);
+}
+function audioSetProp({ audioId, prop, value, startTime, loop, volume, playbackRate, autoplay }) {
+  const audio = _newAudioInstances.get(audioId);
+  if (!audio) return;
+  switch (prop) {
+    case "src":
+      audio.src = value;
+      if (startTime != null) audio.currentTime = startTime;
+      if (loop != null) audio.loop = loop;
+      if (volume != null) audio.volume = Math.max(0, Math.min(1, volume));
+      if (playbackRate != null) audio.playbackRate = playbackRate;
+      if (autoplay) audio.play().catch(() => {
+      });
+      break;
+    case "startTime":
+      audio.currentTime = Number(value) || 0;
+      break;
+    case "autoplay":
+      audio.autoplay = !!value;
+      break;
+    case "loop":
+      audio.loop = !!value;
+      break;
+    case "volume":
+      audio.volume = Math.max(0, Math.min(1, Number(value) || 0));
+      break;
+    case "playbackRate":
+      audio.playbackRate = Number(value) || 1;
+      break;
+  }
+}
+function audioPlay({ audioId, src }) {
+  const audio = _newAudioInstances.get(audioId);
+  if (!audio) return;
+  if (src && audio.src !== src) audio.src = src;
+  audio.play().catch(() => {
+  });
+}
+function audioPause({ audioId }) {
+  _newAudioInstances.get(audioId)?.pause();
+}
+function audioStop({ audioId }) {
+  const audio = _newAudioInstances.get(audioId);
+  if (!audio) return;
+  audio.pause();
+  audio.currentTime = 0;
+  _audioFire.get(audioId)?.(audioSnapshot(audio, "stop"));
+}
+function audioSeek({ audioId, position }) {
+  const audio = _newAudioInstances.get(audioId);
+  if (!audio) return;
+  audio.currentTime = position;
+}
+function audioDestroy({ audioId }) {
+  _audioEventDisposers.get(audioId)?.();
+  _audioEventDisposers.delete(audioId);
+  _audioFire.delete(audioId);
+  const audio = _newAudioInstances.get(audioId);
+  if (!audio) return;
+  audio.pause();
+  audio.removeAttribute("src");
+  audio.load();
+  _newAudioInstances.delete(audioId);
+}
+
+// src/shared/vpath.ts
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var DIFILE_PREFIX = "difile://";
+function sandboxBase() {
+  const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
+  if (env) {
+    return import_node_path.default.join(env, "files");
+  }
+  return import_node_path.default.join(import_node_os.default.homedir(), ".dimina", "files");
+}
+function resolveVPath(url) {
+  if (typeof url !== "string") return null;
+  if (!url.startsWith(DIFILE_PREFIX)) return null;
+  const raw = url.slice(DIFILE_PREFIX.length);
+  if (raw.length === 0) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\0")) return null;
+  decoded = decoded.replace(/^[/\\]+/, "");
+  if (decoded.length === 0) return null;
+  const segments = decoded.split(/[/\\]+/);
+  if (segments.some((s) => s === ".." || s === ".")) return null;
+  let kind;
+  let writable;
+  if (decoded.startsWith("_tmp/")) {
+    kind = "tmp";
+    writable = false;
+  } else if (decoded.startsWith("_store/")) {
+    kind = "store";
+    writable = false;
+  } else {
+    kind = "usr";
+    writable = true;
+  }
+  if (kind === "tmp") {
+    return { kind, writable };
+  }
+  const base = sandboxBase();
+  const joined = import_node_path.default.join(base, decoded);
+  const normalized = import_node_path.default.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + import_node_path.default.sep)) return null;
+  return { kind, writable, realPath: normalized };
+}
+
+// src/simulator/simulator-api-fs.ts
+async function _tmpBytes(url) {
+  try {
+    const blob = await resolveTempFilePath(url);
+    const ab = await blob.arrayBuffer();
+    return Buffer.from(new Uint8Array(ab));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`ENOENT: no such file (${url}): ${msg}`, { cause: err });
+  }
+}
+var _fs = typeof require !== "undefined" ? require("fs") : null;
+var _path = typeof require !== "undefined" ? require("path") : null;
+var _crypto = typeof require !== "undefined" ? require("crypto") : null;
+function _fsResolveOrFail(p, apiName, onFail) {
+  const v = resolveVPath(p);
+  if (!v) {
+    onFail?.({ errMsg: `${apiName}:fail invalid or unsafe path` });
+    return null;
+  }
+  return v;
+}
+function _denyWrite(apiName, onFail) {
+  onFail?.({ errMsg: `${apiName}:fail permission denied` });
+}
+function fsAccess({ path: path2, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsAccess:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(path2, "fsAccess", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind === "tmp") {
+    _tmpBytes(path2).then(
+      () => {
+        onSuccess?.({ errMsg: "fsAccess:ok" });
+        onComplete?.();
+      },
+      (err) => {
+        onFail?.({ errMsg: `fsAccess:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsAccess:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  _fs.access(v.realPath, _fs.constants.F_OK, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsAccess:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsAccess:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsStat({ path: path2, recursive = false, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsStat:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(path2, "fsStat", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind === "tmp") {
+    _tmpBytes(path2).then(
+      (buf) => {
+        onSuccess?.({
+          stats: {
+            size: buf.length,
+            mode: 0,
+            lastAccessedTime: 0,
+            lastModifiedTime: 0,
+            isFile: true,
+            isDirectory: false
+          },
+          errMsg: "fsStat:ok"
+        });
+        onComplete?.();
+      },
+      (err) => {
+        onFail?.({ errMsg: `fsStat:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsStat:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  const resolved = v.realPath;
+  if (recursive) {
+    const statsMap = {};
+    const walkDir = (dir, cb) => {
+      _fs.readdir(dir, { withFileTypes: true }, (err, entries) => {
+        if (err) {
+          cb(err);
+          return;
+        }
+        let pending = entries.length;
+        if (pending === 0) {
+          cb(null);
+          return;
+        }
+        for (const entry of entries) {
+          const full = _path.join(dir, entry.name);
+          _fs.stat(full, (statErr, s) => {
+            if (!statErr) {
+              statsMap[full] = {
+                size: s.size,
+                mode: s.mode,
+                lastAccessedTime: s.atimeMs,
+                lastModifiedTime: s.mtimeMs,
+                isFile: s.isFile(),
+                isDirectory: s.isDirectory()
+              };
+            }
+            if (entry.isDirectory()) {
+              walkDir(full, () => {
+                if (--pending === 0) cb(null);
+              });
+            } else {
+              if (--pending === 0) cb(null);
+            }
+          });
+        }
+      });
+    };
+    walkDir(resolved, (err) => {
+      if (err) {
+        onFail?.({ errMsg: `fsStat:fail ${err.message}` });
+      } else {
+        onSuccess?.({ stats: statsMap, errMsg: "fsStat:ok" });
+      }
+      onComplete?.();
+    });
+  } else {
+    _fs.stat(resolved, (err, s) => {
+      if (err) {
+        onFail?.({ errMsg: `fsStat:fail ${err.message}` });
+      } else {
+        onSuccess?.({
+          stats: {
+            size: s.size,
+            mode: s.mode,
+            lastAccessedTime: s.atimeMs,
+            lastModifiedTime: s.mtimeMs,
+            isFile: s.isFile(),
+            isDirectory: s.isDirectory()
+          },
+          errMsg: "fsStat:ok"
+        });
+      }
+      onComplete?.();
+    });
+  }
+}
+function fsReadFile({ filePath, encoding, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsReadFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsReadFile", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind === "tmp") {
+    _tmpBytes(filePath).then(
+      (buf) => {
+        const data = encoding ? buf.toString(encoding) : buf;
+        onSuccess?.({ data, errMsg: "fsReadFile:ok" });
+        onComplete?.();
+      },
+      (err) => {
+        onFail?.({ errMsg: `fsReadFile:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsReadFile:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  _fs.readFile(v.realPath, encoding || null, (err, data) => {
+    if (err) {
+      onFail?.({ errMsg: `fsReadFile:fail ${err.message}` });
+    } else {
+      onSuccess?.({ data, errMsg: "fsReadFile:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsWriteFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsWriteFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsWriteFile", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsWriteFile", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.mkdir(_path.dirname(v.realPath), { recursive: true }, (mkdirErr) => {
+    if (mkdirErr) {
+      onFail?.({ errMsg: `fsWriteFile:fail ${mkdirErr.message}` });
+      onComplete?.();
+      return;
+    }
+    _fs.writeFile(v.realPath, data, { encoding }, (err) => {
+      if (err) {
+        onFail?.({ errMsg: `fsWriteFile:fail ${err.message}` });
+      } else {
+        onSuccess?.({ errMsg: "fsWriteFile:ok" });
+      }
+      onComplete?.();
+    });
+  });
+}
+function fsAppendFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsAppendFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsAppendFile", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsAppendFile", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.appendFile(v.realPath, data, { encoding }, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsAppendFile:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsAppendFile:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsCopyFile({ srcPath, destPath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsCopyFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const vSrc = _fsResolveOrFail(srcPath, "fsCopyFile", onFail);
+  if (!vSrc) {
+    onComplete?.();
+    return;
+  }
+  const vDest = _fsResolveOrFail(destPath, "fsCopyFile", onFail);
+  if (!vDest) {
+    onComplete?.();
+    return;
+  }
+  if (!vDest.writable || !vDest.realPath) {
+    _denyWrite("fsCopyFile", onFail);
+    onComplete?.();
+    return;
+  }
+  if (vSrc.kind === "tmp") {
+    _tmpBytes(srcPath).then(
+      (buf) => {
+        _fs.mkdir(_path.dirname(vDest.realPath), { recursive: true }, (mkdirErr) => {
+          if (mkdirErr) {
+            onFail?.({ errMsg: `fsCopyFile:fail ${mkdirErr.message}` });
+            onComplete?.();
+            return;
+          }
+          _fs.writeFile(vDest.realPath, buf, (err) => {
+            if (err) onFail?.({ errMsg: `fsCopyFile:fail ${err.message}` });
+            else onSuccess?.({ errMsg: "fsCopyFile:ok" });
+            onComplete?.();
+          });
+        });
+      },
+      (err) => {
+        onFail?.({ errMsg: `fsCopyFile:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!vSrc.realPath) {
+    onFail?.({ errMsg: "fsCopyFile:fail invalid src path" });
+    onComplete?.();
+    return;
+  }
+  _fs.copyFile(vSrc.realPath, vDest.realPath, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsCopyFile:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsCopyFile:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsRename({ oldPath, newPath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsRename:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const vOld = _fsResolveOrFail(oldPath, "fsRename", onFail);
+  if (!vOld) {
+    onComplete?.();
+    return;
+  }
+  const vNew = _fsResolveOrFail(newPath, "fsRename", onFail);
+  if (!vNew) {
+    onComplete?.();
+    return;
+  }
+  if (!vOld.writable || !vOld.realPath) {
+    _denyWrite("fsRename", onFail);
+    onComplete?.();
+    return;
+  }
+  if (!vNew.writable || !vNew.realPath) {
+    _denyWrite("fsRename", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.rename(vOld.realPath, vNew.realPath, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsRename:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsRename:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsUnlink({ filePath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsUnlink:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsUnlink", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsUnlink", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.unlink(v.realPath, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsUnlink:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsUnlink:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsMkdir({ dirPath, recursive = false, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsMkdir:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(dirPath, "fsMkdir", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsMkdir", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.mkdir(v.realPath, { recursive }, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsMkdir:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsMkdir:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsRmdir({ dirPath, recursive = false, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsRmdir:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(dirPath, "fsRmdir", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsRmdir", onFail);
+    onComplete?.();
+    return;
+  }
+  const rmFn = _fs.rm ?? _fs.rmdir;
+  rmFn(v.realPath, { recursive }, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsRmdir:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsRmdir:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsReaddir({ dirPath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsReaddir:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(dirPath, "fsReaddir", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind === "tmp" || v.kind === "store") {
+    onFail?.({ errMsg: `fsReaddir:fail ${v.kind} is a flat namespace (no dir tree)` });
+    onComplete?.();
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsReaddir:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  _fs.readdir(v.realPath, (err, files) => {
+    if (err) {
+      onFail?.({ errMsg: `fsReaddir:fail ${err.message}` });
+    } else {
+      onSuccess?.({ files, errMsg: "fsReaddir:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsGetFileInfo({ filePath, digestAlgorithm, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsGetFileInfo:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsGetFileInfo", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind === "tmp") {
+    _tmpBytes(filePath).then(
+      (buf) => {
+        const result = { size: buf.length, errMsg: "fsGetFileInfo:ok" };
+        if (digestAlgorithm) {
+          try {
+            const hash = _crypto.createHash(digestAlgorithm === "md5" ? "md5" : "sha1");
+            hash.update(buf);
+            result.digest = hash.digest("hex");
+          } catch {
+          }
+        }
+        onSuccess?.(result);
+        onComplete?.();
+      },
+      (err) => {
+        onFail?.({ errMsg: `fsGetFileInfo:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsGetFileInfo:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  const resolved = v.realPath;
+  _fs.stat(resolved, (err, s) => {
+    if (err) {
+      onFail?.({ errMsg: `fsGetFileInfo:fail ${err.message}` });
+      onComplete?.();
+      return;
+    }
+    const result = { size: s.size, errMsg: "fsGetFileInfo:ok" };
+    if (digestAlgorithm) {
+      try {
+        const hash = _crypto.createHash(digestAlgorithm === "md5" ? "md5" : "sha1");
+        const stream = _fs.createReadStream(resolved);
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => {
+          result.digest = hash.digest("hex");
+          onSuccess?.(result);
+          onComplete?.();
+        });
+        stream.on("error", (hashErr) => {
+          onFail?.({ errMsg: `fsGetFileInfo:fail ${hashErr.message}` });
+          onComplete?.();
+        });
+        return;
+      } catch {
+      }
+    }
+    onSuccess?.(result);
+    onComplete?.();
+  });
+}
+function fsSaveFile({ tempFilePath, filePath: _filePath, success, fail, complete }) {
+  void _filePath;
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsSaveFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const src = _fsResolveOrFail(tempFilePath, "fsSaveFile", onFail);
+  if (!src) {
+    onComplete?.();
+    return;
+  }
+  const ext = _path.extname(tempFilePath) || "";
+  const id = _crypto.randomUUID() + ext;
+  const savedFilePath = `difile://_store/${id}`;
+  const destResolved = resolveVPath(savedFilePath);
+  if (!destResolved || !destResolved.realPath) {
+    onFail?.({ errMsg: "fsSaveFile:fail unable to allocate destination" });
+    onComplete?.();
+    return;
+  }
+  const destReal = destResolved.realPath;
+  function writeBytesToStore(bytes) {
+    _fs.mkdir(_path.dirname(destReal), { recursive: true }, (mkdirErr) => {
+      if (mkdirErr) {
+        onFail?.({ errMsg: `fsSaveFile:fail ${mkdirErr.message}` });
+        onComplete?.();
+        return;
+      }
+      _fs.writeFile(destReal, bytes, (err) => {
+        if (err) onFail?.({ errMsg: `fsSaveFile:fail ${err.message}` });
+        else onSuccess?.({ savedFilePath, errMsg: "fsSaveFile:ok" });
+        onComplete?.();
+      });
+    });
+  }
+  if (src.kind === "tmp") {
+    _tmpBytes(tempFilePath).then(
+      writeBytesToStore,
+      (err) => {
+        onFail?.({ errMsg: `fsSaveFile:fail ${err.message}` });
+        onComplete?.();
+      }
+    );
+    return;
+  }
+  if (!src.realPath) {
+    onFail?.({ errMsg: "fsSaveFile:fail invalid src path" });
+    onComplete?.();
+    return;
+  }
+  _fs.mkdir(_path.dirname(destReal), { recursive: true }, (mkdirErr) => {
+    if (mkdirErr) {
+      onFail?.({ errMsg: `fsSaveFile:fail ${mkdirErr.message}` });
+      onComplete?.();
+      return;
+    }
+    _fs.copyFile(src.realPath, destReal, (err) => {
+      if (err) {
+        onFail?.({ errMsg: `fsSaveFile:fail ${err.message}` });
+      } else {
+        onSuccess?.({ savedFilePath, errMsg: "fsSaveFile:ok" });
+      }
+      onComplete?.();
+    });
+  });
+}
+function fsGetSavedFileList({ success, fail, complete } = {}) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsGetSavedFileList:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const storeVpath = resolveVPath("difile://_store/");
+  const storeDir = storeVpath?.realPath;
+  if (!storeDir) {
+    onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
+    onComplete?.();
+    return;
+  }
+  _fs.readdir(storeDir, (err, files) => {
+    if (err) {
+      onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
+      onComplete?.();
+      return;
+    }
+    let pending = files.length;
+    if (pending === 0) {
+      onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
+      onComplete?.();
+      return;
+    }
+    const fileList = [];
+    for (const name of files) {
+      const full = _path.join(storeDir, name);
+      _fs.stat(full, (statErr, s) => {
+        if (!statErr) {
+          fileList.push({
+            filePath: `difile://_store/${name}`,
+            size: s.size,
+            createTime: s.birthtimeMs
+          });
+        }
+        if (--pending === 0) {
+          onSuccess?.({ fileList, errMsg: "fsGetSavedFileList:ok" });
+          onComplete?.();
+        }
+      });
+    }
+  });
+}
+function fsRemoveSavedFile({ filePath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsRemoveSavedFile:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsRemoveSavedFile", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (v.kind !== "store" || !v.realPath) {
+    onFail?.({ errMsg: "fsRemoveSavedFile:fail only _store/ entries may be removed" });
+    onComplete?.();
+    return;
+  }
+  _fs.unlink(v.realPath, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsRemoveSavedFile:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsRemoveSavedFile:ok" });
+    }
+    onComplete?.();
+  });
+}
+function fsTruncate({ filePath, length = 0, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  if (!_fs) {
+    onFail?.({ errMsg: "fsTruncate:fail not available in browser context" });
+    onComplete?.();
+    return;
+  }
+  const v = _fsResolveOrFail(filePath, "fsTruncate", onFail);
+  if (!v) {
+    onComplete?.();
+    return;
+  }
+  if (!v.writable || !v.realPath) {
+    _denyWrite("fsTruncate", onFail);
+    onComplete?.();
+    return;
+  }
+  _fs.truncate(v.realPath, length, (err) => {
+    if (err) {
+      onFail?.({ errMsg: `fsTruncate:fail ${err.message}` });
+    } else {
+      onSuccess?.({ errMsg: "fsTruncate:ok" });
+    }
+    onComplete?.();
+  });
+}
+var fsUnzip = notSupportedApi("fsUnzip");
+
+// src/simulator/simulator-api-network.ts
+function downloadFile({ url, header = {}, filePath, success, fail, complete }) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  fetch(url, { headers: header }).then(async (response) => {
+    if (!response.ok) throw new Error(response.statusText);
+    const blob = await response.blob();
+    const tempFilePath = createTempFilePath(blob);
+    onSuccess?.({
+      tempFilePath,
+      filePath: filePath || tempFilePath,
+      statusCode: response.status,
+      errMsg: "downloadFile:ok"
+    });
+  }).catch((error) => {
+    onFail?.({ errMsg: `downloadFile:fail ${error.message}` });
+  }).finally(() => {
+    onComplete?.();
+  });
+}
+var uploadRequests = /* @__PURE__ */ new Map();
+var uploadPendingResolves = /* @__PURE__ */ new Set();
+var uploadAbortedBeforeStart = /* @__PURE__ */ new Set();
+var nextUploadId = 1;
+function createUploadId() {
+  return `upload_${Date.now()}_${nextUploadId++}`;
+}
+function parseResponseHeaders(raw) {
+  const headers = {};
+  for (const line of raw.trim().split(/[\r\n]+/)) {
+    if (!line) continue;
+    const index = line.indexOf(":");
+    if (index <= 0) continue;
+    const key = line.slice(0, index).trim();
+    const value = line.slice(index + 1).trim();
+    if (key) headers[key] = value;
+  }
+  return headers;
+}
+function appendFormData(form, formData) {
+  for (const [key, value] of Object.entries(formData)) {
+    if (value == null) continue;
+    if (value instanceof Blob) {
+      form.append(key, value);
+    } else if (typeof value === "object") {
+      form.append(key, JSON.stringify(value));
+    } else {
+      form.append(key, String(value));
+    }
+  }
+}
+function uploadFile({
+  url,
+  filePath,
+  name,
+  header = {},
+  formData = {},
+  timeout,
+  uploadId = createUploadId(),
+  progress,
+  headersReceived,
+  success,
+  fail,
+  complete
+}) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const onProgress = this.createCallbackFunction(progress);
+  const onHeadersReceived = this.createCallbackFunction(headersReceived);
+  const cleanup = () => {
+    uploadRequests.delete(uploadId);
+    uploadPendingResolves.delete(uploadId);
+    uploadAbortedBeforeStart.delete(uploadId);
+  };
+  const finishFail = (message) => {
+    cleanup();
+    const result = { errMsg: `uploadFile:fail ${message}` };
+    onFail?.(result);
+    onComplete?.(result);
+  };
+  uploadPendingResolves.add(uploadId);
+  void resolveTempFilePath(filePath).then((blob) => {
+    uploadPendingResolves.delete(uploadId);
+    if (uploadAbortedBeforeStart.has(uploadId)) {
+      finishFail("abort");
+      return;
+    }
+    const xhr = new XMLHttpRequest();
+    let settled = false;
+    let deliveredHeaders = false;
+    uploadRequests.set(uploadId, xhr);
+    const finishSuccess = () => {
+      if (settled) return;
+      settled = true;
+      const headers = parseResponseHeaders(xhr.getAllResponseHeaders());
+      cleanup();
+      const result = {
+        data: typeof xhr.response === "string" ? xhr.response : xhr.responseText,
+        statusCode: xhr.status,
+        header: headers,
+        errMsg: "uploadFile:ok"
+      };
+      onSuccess?.(result);
+      onComplete?.(result);
+    };
+    const finishXhrFail = (message) => {
+      if (settled) return;
+      settled = true;
+      finishFail(message);
+    };
+    const emitHeaders = () => {
+      if (deliveredHeaders) return;
+      deliveredHeaders = true;
+      onHeadersReceived?.({ header: parseResponseHeaders(xhr.getAllResponseHeaders()) });
+    };
+    xhr.open("POST", url, true);
+    if (timeout === void 0) {
+      xhr.timeout = 6e4;
+    } else if (Number(timeout) > 0) {
+      xhr.timeout = Number(timeout);
+    }
+    for (const [key, value] of Object.entries(header)) {
+      if (/^(referer|content-type)$/i.test(key)) continue;
+      xhr.setRequestHeader(key, String(value));
+    }
+    xhr.upload.onprogress = (event) => {
+      const totalBytesExpectedToSend = event.lengthComputable ? event.total : blob.size;
+      const progressValue = totalBytesExpectedToSend > 0 ? Math.round(event.loaded / totalBytesExpectedToSend * 100) : 0;
+      onProgress?.({
+        progress: Math.max(0, Math.min(100, progressValue)),
+        totalBytesSent: event.loaded,
+        totalBytesExpectedToSend
+      });
+    };
+    xhr.onreadystatechange = () => {
+      if (xhr.readyState >= XMLHttpRequest.HEADERS_RECEIVED) emitHeaders();
+    };
+    xhr.onload = () => {
+      emitHeaders();
+      finishSuccess();
+    };
+    xhr.onerror = () => finishXhrFail("network error");
+    xhr.ontimeout = () => finishXhrFail("timeout");
+    xhr.onabort = () => finishXhrFail("abort");
+    const body = new FormData();
+    appendFormData(body, formData);
+    body.append(name, blob, getTempFileName(filePath, blob, name || "file"));
+    xhr.send(body);
+  }).catch((error) => {
+    finishFail(error.message);
+  });
+}
+function uploadFileAbort({ uploadId } = {}) {
+  if (!uploadId) return;
+  const xhr = uploadRequests.get(uploadId);
+  if (xhr) {
+    xhr.abort();
+    return;
+  }
+  if (uploadPendingResolves.has(uploadId)) {
+    uploadAbortedBeforeStart.add(uploadId);
+  }
+}
+
+// src/simulator/simulator-api.ts
+function canIUse({ success, complete }) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  onSuccess?.(true);
+  onComplete?.();
+  return true;
+}
+function getWindowInfo({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const { wb, di, pixelRatio, screenWidth, screenHeight, windowWidth, windowHeight } = readWindowMetrics(this);
+  const bar = this.parent?.getStatusBarRect?.() ?? { height: 0 };
+  const statusBarHeight = di["statusBarHeight"] ?? bar.height;
+  const info = {
+    pixelRatio,
+    screenWidth,
+    screenHeight,
+    windowWidth,
+    windowHeight,
+    statusBarHeight,
+    safeArea: {
+      width: wb.width,
+      height: wb.height - statusBarHeight,
+      top: statusBarHeight,
+      bottom: wb.height,
+      left: 0,
+      right: wb.width
+    }
+  };
+  onSuccess?.(info);
+  onComplete?.();
+  return info;
+}
+function getSystemSetting({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const info = {
+    bluetoothEnabled: false,
+    locationEnabled: true,
+    wifiEnabled: true,
+    deviceOrientation: "portrait"
+  };
+  onSuccess?.(info);
+  onComplete?.();
+  return info;
+}
+function readWindowMetrics(miniApp) {
+  const wb = miniApp.parent?.el?.querySelector(".dimina-native-webview__root")?.getBoundingClientRect() ?? { width: 375, height: 812 };
+  const di = window.__deviceInfo || {};
+  return {
+    wb,
+    di,
+    pixelRatio: di["pixelRatio"] || window.devicePixelRatio || 2,
+    screenWidth: di["screenWidth"] || wb.width,
+    screenHeight: di["screenHeight"] || wb.height,
+    windowWidth: wb.width,
+    windowHeight: wb.height
+  };
+}
+function buildSystemInfo(miniApp) {
+  const { wb, di, pixelRatio, screenWidth, screenHeight, windowWidth, windowHeight } = readWindowMetrics(miniApp);
+  const statusBarHeight = di["statusBarHeight"] ?? 0;
+  const safeAreaBottom = di["safeAreaBottom"] ?? 0;
+  return {
+    brand: di["brand"] || "devtools",
+    model: di["model"] || "devtools",
+    pixelRatio,
+    screenWidth,
+    screenHeight,
+    windowWidth,
+    windowHeight,
+    statusBarHeight,
+    language: "zh_CN",
+    version: "8.0.5",
+    system: di["system"] || "iOS 16.0",
+    platform: di["platform"] || "ios",
+    fontSizeSetting: 16,
+    SDKVersion: "3.0.0",
+    deviceOrientation: "portrait",
+    safeArea: {
+      width: wb.width,
+      height: wb.height - statusBarHeight - safeAreaBottom,
+      top: statusBarHeight,
+      bottom: wb.height - safeAreaBottom,
+      left: 0,
+      right: wb.width
+    }
+  };
+}
+function getSystemInfoAsync(opts) {
+  const { success, complete } = opts;
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  onSuccess?.(buildSystemInfo(this));
+  onComplete?.();
+}
+function getSystemInfo(opts) {
+  getSystemInfoAsync.call(this, opts);
+}
+function getSystemInfoSync() {
+  return buildSystemInfo(this);
+}
+function getAccountInfoSync() {
+  return {
+    miniProgram: {
+      appId: this.appId || "",
+      envVersion: "develop",
+      version: ""
+    }
+  };
+}
+var simulatorApis = {
+  // Base
+  canIUse,
+  getSystemInfo,
+  getSystemInfoAsync,
+  getSystemInfoSync,
+  getWindowInfo,
+  getSystemSetting,
+  // Network
+  downloadFile,
+  uploadFile,
+  uploadFileAbort,
+  // Storage (sync)
+  setStorageSync,
+  getStorageSync,
+  removeStorageSync,
+  clearStorageSync,
+  getStorageInfoSync,
+  // Storage (async)
+  setStorage,
+  getStorage,
+  removeStorage,
+  clearStorage,
+  getStorageInfo,
+  // Open API
+  getAccountInfoSync,
+  // Device
+  hideKeyboard,
+  adjustPosition,
+  makePhoneCall,
+  chooseContact,
+  addPhoneContact,
+  vibrateShort,
+  vibrateLong,
+  scanCode,
+  // Media: Image
+  chooseImage,
+  previewImage,
+  compressImage,
+  saveImageToPhotosAlbum,
+  getImageInfo,
+  // Media: Video
+  chooseMedia,
+  chooseVideo,
+  // Media: Audio (service-apis/audio)
+  audioCreate,
+  audioListen,
+  audioSetProp,
+  audioPlay,
+  audioPause,
+  audioStop,
+  audioSeek,
+  audioDestroy,
+  // Filesystem (service-apis/file)
+  fsAccess,
+  fsStat,
+  fsReadFile,
+  fsWriteFile,
+  fsAppendFile,
+  fsCopyFile,
+  fsRename,
+  fsUnlink,
+  fsMkdir,
+  fsRmdir,
+  fsReaddir,
+  fsGetFileInfo,
+  fsSaveFile,
+  fsGetSavedFileList,
+  fsRemoveSavedFile,
+  fsTruncate,
+  fsUnzip
+};
+
+// src/preload/windows/main.ts
 var api = {
   ipc: {
     invoke: (channel, ...args) => import_electron.ipcRenderer.invoke(channel, ...args),
+    // Synchronous round-trip. Blocks the renderer until the main process sets
+    // `event.returnValue` — used only for the editor's beforeunload flush, where
+    // the write MUST land before the page is torn down (an async invoke can't).
+    sendSync: (channel, ...args) => import_electron.ipcRenderer.sendSync(channel, ...args),
     send: (channel, ...args) => {
       import_electron.ipcRenderer.send(channel, ...args);
     },
@@ -36,6 +1959,22 @@ var api = {
   }
 };
 import_electron.contextBridge.exposeInMainWorld("devtools", api);
+import_electron.ipcRenderer.on(SIMULATOR_EVENTS.API_CALL, (_event, payload) => {
+  void runApiAsync(
+    simulatorApis,
+    payload.name,
+    payload.params
+  ).then((verdict) => {
+    const ack = {
+      appSessionId: payload.appSessionId,
+      requestId: payload.requestId,
+      ok: verdict.ok,
+      result: verdict.result,
+      errMsg: verdict.errMsg
+    };
+    import_electron.ipcRenderer.send(BRIDGE_CHANNELS.API_RESPONSE, ack);
+  });
+});
 if (process.env.NODE_ENV === "test") {
   import_electron.contextBridge.exposeInMainWorld("__testIpc", {
     emit: (channel, ...args) => {