@dimina-kit/devtools 0.4.0-dev.20260729062524 → 0.4.0-dev.20260801163345

package/dist/preload/windows/main.cjs

@@ -28,7 +28,7 @@ var main_exports = {};
 module.exports = __toCommonJS(main_exports);
 var import_electron = require("electron");
 
-// src/shared/bridge-channels.ts
+// ../dimina-electron-runtime/dist/shared/bridge-channels.js
 var BRIDGE_CHANNELS = {
   SPAWN: "dmb:spawn",
   DISPOSE: "dmb:dispose",
@@ -108,8 +108,8 @@ function makeBaseContext() {
     }
   };
 }
-function runApiAsync(handlers, name, params) {
-  const handler = handlers[name];
+function runApiAsync(handlers2, name, params) {
+  const handler = handlers2[name];
   if (!handler) {
     return Promise.resolve({ ok: false, errMsg: `${name}:fail no handler` });
   }
@@ -322,36 +322,45 @@ function vibrateLong({ success, complete } = {}) {
   onComplete?.();
 }
 var scanCode = notSupportedApi("scanCode");
+function getClipboardBridge() {
+  return window.__diminaClipboard;
+}
 function getClipboardData({ success, fail, complete } = {}) {
   const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
-  return navigator.clipboard.readText().then(
-    (data) => {
-      onSuccess?.({ data, errMsg: "getClipboardData:ok" });
-      onComplete?.();
-    },
-    (error) => {
-      onFail?.({ errMsg: `getClipboardData:fail ${error?.message ?? error}` });
-      onComplete?.();
-    }
-  );
+  const bridge = getClipboardBridge();
+  if (!bridge) {
+    onFail?.({ errMsg: "getClipboardData:fail clipboard bridge unavailable" });
+    onComplete?.();
+    return;
+  }
+  try {
+    const data = bridge.readText();
+    onSuccess?.({ data, errMsg: "getClipboardData:ok" });
+  } catch (error) {
+    onFail?.({ errMsg: `getClipboardData:fail ${error?.message ?? error}` });
+  }
+  onComplete?.();
 }
 function setClipboardData({ data, success, fail, complete } = {}) {
   const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
   if (typeof data !== "string") {
     onFail?.({ errMsg: "setClipboardData:fail data is required" });
     onComplete?.();
-    return Promise.resolve();
+    return;
   }
-  return navigator.clipboard.writeText(data).then(
-    () => {
-      onSuccess?.({ errMsg: "setClipboardData:ok" });
-      onComplete?.();
-    },
-    (error) => {
-      onFail?.({ errMsg: `setClipboardData:fail ${error?.message ?? error}` });
-      onComplete?.();
-    }
-  );
+  const bridge = getClipboardBridge();
+  if (!bridge) {
+    onFail?.({ errMsg: "setClipboardData:fail clipboard bridge unavailable" });
+    onComplete?.();
+    return;
+  }
+  try {
+    bridge.writeText(data);
+    onSuccess?.({ errMsg: "setClipboardData:ok" });
+  } catch (error) {
+    onFail?.({ errMsg: `setClipboardData:fail ${error?.message ?? error}` });
+  }
+  onComplete?.();
 }
 function mapEffectiveType(effectiveType) {
   switch (effectiveType) {
@@ -403,6 +412,71 @@ function bindDomEvents(target, eventMap, fire, buildPayload) {
   };
 }
 
+// ../dimina-electron-runtime/dist/shared/node-bindings.js
+var NODE_BINDINGS_GLOBAL = "__diminaNodeBindings";
+function getNodeBindings() {
+  const bag = globalThis[NODE_BINDINGS_GLOBAL];
+  return bag && typeof bag === "object" ? bag : {};
+}
+
+// ../dimina-electron-runtime/dist/shared/vpath.js
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var os = typeof import_node_os.default?.homedir === "function" ? import_node_os.default : getNodeBindings().os ?? import_node_os.default;
+var path = typeof import_node_path.default?.join === "function" ? import_node_path.default : getNodeBindings().path ?? import_node_path.default;
+var DIFILE_PREFIX = "difile://";
+function sandboxBase() {
+  const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
+  if (env) {
+    return path.join(env, "files");
+  }
+  return path.join(os.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 = path.join(base, decoded);
+  const normalized = path.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + path.sep))
+    return null;
+  return { kind, writable, realPath: normalized };
+}
+
 // src/simulator/temp-files.ts
 var tempFiles = /* @__PURE__ */ new Map();
 var activeSink = null;
@@ -442,988 +516,1227 @@ function getTempFileName(path2, blob, fallback = "file") {
   return fallback;
 }
 
-// src/simulator/simulator-api-media.ts
-function captureAttrFor(sourceType, camera) {
-  if (sourceType.length !== 1 || sourceType[0] !== "camera") return void 0;
-  return camera === "front" ? "user" : "environment";
+// src/simulator/simulator-api-fs.ts
+async function _tmpBytes(url) {
+  try {
+    const blob = await resolveTempFilePath(url);
+    return await blobToBuffer(blob);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`ENOENT: no such file (${url}): ${msg}`, { cause: err });
+  }
 }
-function createFilePicker(apiName, config, cbs, onPick) {
-  const input = document.createElement("input");
-  input.type = "file";
-  input.accept = config.accept;
-  input.multiple = config.multiple;
-  if (config.capture) input.setAttribute("capture", config.capture);
-  input.style.display = "none";
-  document.body.appendChild(input);
-  const removeInput = () => input.remove();
-  input.addEventListener("change", () => {
-    const files = Array.from(input.files || []);
-    if (files.length === 0) {
-      cbs.onFail?.({ errMsg: `${apiName}:fail cancel` });
-      cbs.onComplete?.();
-      removeInput();
-      return;
-    }
-    void onPick(files, removeInput);
-  });
-  input.click();
+function isArrayBuffer(value) {
+  return Object.prototype.toString.call(value) === "[object ArrayBuffer]";
 }
-function chooseImage({ count = 9, sourceType, camera, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onSuccess, onComplete } = cbs;
-  const normalizedCount = normalizeChooseMediaCount(count);
-  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
-  createFilePicker(
-    "chooseImage",
-    { accept: "image/*", multiple: normalizedCount > 1, capture: captureAttrFor(normalizedSourceType, camera) },
-    cbs,
-    (rawFiles, removeInput) => {
-      const files = rawFiles.slice(0, normalizedCount);
-      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?.();
-      removeInput();
-    }
-  );
+var BufferImpl = getNodeBindings().buffer?.Buffer ?? (typeof Buffer !== "undefined" ? Buffer : void 0);
+async function blobToBuffer(blob) {
+  if (!BufferImpl) {
+    throw new Error("Buffer binding unavailable");
+  }
+  const readable = blob;
+  if (typeof readable.arrayBuffer === "function") {
+    const ab = await readable.arrayBuffer();
+    return BufferImpl.from(new Uint8Array(ab));
+  }
+  if (typeof FileReader !== "function") {
+    throw new Error("Blob cannot be read as ArrayBuffer");
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error("Blob read failed"));
+    reader.onload = () => {
+      const result = reader.result;
+      if (!isArrayBuffer(result)) {
+        reject(new Error("Blob read did not return an ArrayBuffer"));
+        return;
+      }
+      resolve(BufferImpl.from(new Uint8Array(result)));
+    };
+    reader.readAsArrayBuffer(blob);
+  });
 }
-function previewImage({ urls, current, success, complete }) {
-  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
-  if (!urls || urls.length === 0) {
-    onComplete?.();
-    return;
+function resolveNodeModule(fromBindings, name, probe) {
+  if (fromBindings && probe(fromBindings)) return fromBindings;
+  if (typeof require !== "undefined") {
+    const mod = require(name);
+    if (mod && probe(mod)) return mod;
   }
-  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?.();
+  return null;
 }
-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 = () => {
+var _fs = resolveNodeModule(getNodeBindings().fs, "fs", (m) => typeof m.readFile === "function");
+var _path = resolveNodeModule(getNodeBindings().path, "path", (m) => typeof m.join === "function");
+var _crypto = resolveNodeModule(getNodeBindings().crypto, "crypto", (m) => typeof m.createHash === "function");
+function guardFsAvailable(apiName, cbs) {
+  if (_fs) return false;
+  cbs.onFail?.({ errMsg: `${apiName}:fail not available in browser context` });
+  cbs.onComplete?.();
+  return true;
+}
+function containsSymlink(realPath) {
+  const rel = _path.relative(sandboxBase(), realPath);
+  if (!rel || rel.startsWith("..")) return false;
+  let cur = sandboxBase();
+  for (const seg of rel.split(_path.sep)) {
+    cur = _path.join(cur, seg);
+    let entry;
     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?.();
+      entry = _fs.lstatSync(cur);
+    } catch {
+      return false;
     }
-  };
-  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}` });
+    if (entry.isSymbolicLink()) return true;
   }
-  onComplete?.();
+  return false;
 }
-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?.();
+function resolveOrBail(p, apiName, cbs) {
+  const v = resolveVPath(p);
+  if (v && (!v.realPath || !_fs || !containsSymlink(v.realPath))) return v;
+  cbs.onFail?.({ errMsg: `${apiName}:fail invalid or unsafe path` });
+  cbs.onComplete?.();
+  return void 0;
+}
+function toWxStats(s) {
+  return {
+    size: s.size,
+    mode: s.mode,
+    lastAccessedTime: Math.floor(s.atimeMs / 1e3),
+    lastModifiedTime: Math.floor(s.mtimeMs / 1e3),
+    isFile: s.isFile(),
+    isDirectory: s.isDirectory()
   };
-  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 ensureWritable(v, apiName, cbs) {
+  if (v.writable && v.realPath) return true;
+  cbs.onFail?.({ errMsg: `${apiName}:fail permission denied` });
+  cbs.onComplete?.();
+  return false;
 }
-function normalizeChooseMediaCount(value) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return 9;
-  return Math.max(1, Math.min(20, Math.floor(n)));
+function tmpFailHandler(apiName, cbs) {
+  return (err) => {
+    cbs.onFail?.({ errMsg: `${apiName}:fail ${err.message}` });
+    cbs.onComplete?.();
+  };
 }
-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 nodeComplete(apiName, cbs, buildOk) {
+  return (err, ...args) => {
+    if (err) {
+      cbs.onFail?.({ errMsg: `${apiName}:fail ${err.message}` });
+    } else {
+      cbs.onSuccess?.({ ...buildOk ? buildOk(...args) : void 0, errMsg: `${apiName}:ok` });
+    }
+    cbs.onComplete?.();
+  };
 }
-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 mkdirpThenWrite(destReal, apiName, cbs, writeFn, okExtra) {
+  _fs.mkdir(_path.dirname(destReal), { recursive: true }, (mkdirErr) => {
+    if (mkdirErr) {
+      cbs.onFail?.({ errMsg: `${apiName}:fail ${mkdirErr.message}` });
+      cbs.onComplete?.();
+      return;
+    }
+    try {
+      writeFn(nodeComplete(apiName, cbs, () => okExtra));
+    } catch (err) {
+      cbs.onFail?.({ errMsg: `${apiName}:fail ${err instanceof Error ? err.message : String(err)}` });
+      cbs.onComplete?.();
+    }
   });
 }
-function readVideoMetadata(src) {
-  return new Promise((resolve) => {
-    const video = document.createElement("video");
+function fsAccess({ path: path2, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onSuccess, onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsAccess", cbs)) return;
+  const v = resolveOrBail(path2, "fsAccess", cbs);
+  if (!v) return;
+  if (v.kind === "tmp") {
+    _tmpBytes(path2).then(
+      () => {
+        onSuccess?.({ errMsg: "fsAccess:ok" });
+        onComplete?.();
+      },
+      tmpFailHandler("fsAccess", cbs)
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsAccess:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  _fs.access(v.realPath, _fs.constants.F_OK, nodeComplete("fsAccess", cbs));
+}
+function fsStat({ path: path2, recursive = false, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onSuccess, onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsStat", cbs)) return;
+  const v = resolveOrBail(path2, "fsStat", cbs);
+  if (!v) 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?.();
+      },
+      tmpFailHandler("fsStat", cbs)
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsStat:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  const resolved = v.realPath;
+  if (recursive) {
+    const statsMap = {};
     let settled = false;
-    let seekTimer;
-    const finish = (metadata) => {
+    const failOnce = (err) => {
       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);
+      onFail?.({ errMsg: `fsStat:fail ${err.message}` });
+      onComplete?.();
     };
-    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("");
+    const okOnce = () => {
+      if (settled) return;
+      settled = true;
+      onSuccess?.({ stats: statsMap, errMsg: "fsStat:ok" });
+      onComplete?.();
+    };
+    const relKey = (full) => {
+      const rel = _path.relative(resolved, full);
+      return rel === "" ? "." : rel.split(_path.sep).join("/");
+    };
+    const statInto = (full, cb) => {
+      _fs.lstat(full, (err, s) => {
+        if (err) {
+          cb(err);
           return;
         }
-        const toDataUrlFallback = () => {
-          try {
-            done(canvas.toDataURL("image/jpeg", 0.8));
-          } catch {
-            done("");
+        if (s.isSymbolicLink()) {
+          cb(new Error("invalid or unsafe path"));
+          return;
+        }
+        statsMap[relKey(full)] = toWxStats(s);
+        cb(null, s.isDirectory());
+      });
+    };
+    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;
+        }
+        let erred = false;
+        const done = (e) => {
+          if (erred) return;
+          if (e) {
+            erred = true;
+            cb(e);
+            return;
           }
+          if (--pending === 0) cb(null);
         };
-        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();
+        for (const entry of entries) {
+          const full = _path.join(dir, entry.name);
+          statInto(full, (statErr, isDirectory) => {
+            if (statErr) {
+              done(statErr);
+              return;
+            }
+            if (isDirectory) walkDir(full, done);
+            else done(null);
+          });
         }
       });
     };
-    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);
+    statInto(resolved, (rootErr) => {
+      if (rootErr) {
+        failOnce(rootErr);
         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
-    };
+      walkDir(resolved, (err) => {
+        if (err) failOnce(err);
+        else okOnce();
+      });
+    });
+  } else {
+    _fs.stat(resolved, nodeComplete("fsStat", cbs, (s) => ({
+      stats: toWxStats(s)
+    })));
   }
-  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 }) {
+function fsReadFile({ filePath, encoding, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
   const { onSuccess, onFail, onComplete } = cbs;
-  const normalizedCount = normalizeChooseMediaCount(count);
-  const normalizedMediaType = normalizeStringArray(mediaType, ["image", "video"]);
-  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
-  createFilePicker(
-    "chooseMedia",
-    {
-      accept: getChooseMediaAccept(normalizedMediaType),
-      multiple: normalizedCount > 1,
-      capture: captureAttrFor(normalizedSourceType, camera)
-    },
-    cbs,
-    async (rawFiles, removeInput) => {
-      const files = rawFiles.slice(0, normalizedCount);
-      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 {
+  if (guardFsAvailable("fsReadFile", cbs)) return;
+  const v = resolveOrBail(filePath, "fsReadFile", cbs);
+  if (!v) return;
+  if (v.kind === "tmp") {
+    _tmpBytes(filePath).then(
+      (buf) => {
+        const data = encoding ? buf.toString(encoding) : buf;
+        onSuccess?.({ data, errMsg: "fsReadFile:ok" });
         onComplete?.();
-        removeInput();
-      }
-    }
-  );
+      },
+      tmpFailHandler("fsReadFile", cbs)
+    );
+    return;
+  }
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsReadFile:fail invalid path" });
+    onComplete?.();
+    return;
+  }
+  _fs.readFile(v.realPath, encoding || null, nodeComplete("fsReadFile", cbs, (data) => ({ data })));
 }
-function chooseVideo({ sourceType, camera, success, fail, complete }) {
+function fsWriteFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onSuccess, onComplete } = cbs;
-  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
-  createFilePicker(
-    "chooseVideo",
-    { accept: "video/*", multiple: false, capture: captureAttrFor(normalizedSourceType, camera) },
-    cbs,
-    async (files, removeInput) => {
-      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?.();
-      removeInput();
-    }
-  );
-}
-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());
+  if (guardFsAvailable("fsWriteFile", cbs)) return;
+  const v = resolveOrBail(filePath, "fsWriteFile", cbs);
+  if (!v) return;
+  if (!ensureWritable(v, "fsWriteFile", cbs)) return;
+  mkdirpThenWrite(v.realPath, "fsWriteFile", cbs, (done) => _fs.writeFile(v.realPath, data, { encoding }, done));
 }
-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 fsAppendFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  if (guardFsAvailable("fsAppendFile", cbs)) return;
+  const v = resolveOrBail(filePath, "fsAppendFile", cbs);
+  if (!v) return;
+  if (!ensureWritable(v, "fsAppendFile", cbs)) return;
+  _fs.appendFile(v.realPath, data, { encoding }, nodeComplete("fsAppendFile", cbs));
 }
-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 fsCopyFile({ srcPath, destPath, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsCopyFile", cbs)) return;
+  const vSrc = resolveOrBail(srcPath, "fsCopyFile", cbs);
+  if (!vSrc) return;
+  const vDest = resolveOrBail(destPath, "fsCopyFile", cbs);
+  if (!vDest) return;
+  if (!ensureWritable(vDest, "fsCopyFile", cbs)) return;
+  if (vSrc.kind === "tmp") {
+    _tmpBytes(srcPath).then(
+      (buf) => mkdirpThenWrite(vDest.realPath, "fsCopyFile", cbs, (done) => _fs.writeFile(vDest.realPath, buf, done)),
+      tmpFailHandler("fsCopyFile", cbs)
+    );
+    return;
   }
+  if (!vSrc.realPath) {
+    onFail?.({ errMsg: "fsCopyFile:fail invalid src path" });
+    onComplete?.();
+    return;
+  }
+  _fs.copyFile(vSrc.realPath, vDest.realPath, nodeComplete("fsCopyFile", cbs));
 }
-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 fsRename({ oldPath, newPath, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  if (guardFsAvailable("fsRename", cbs)) return;
+  const vOld = resolveOrBail(oldPath, "fsRename", cbs);
+  if (!vOld) return;
+  const vNew = resolveOrBail(newPath, "fsRename", cbs);
+  if (!vNew) return;
+  if (!ensureWritable(vOld, "fsRename", cbs)) return;
+  if (!ensureWritable(vNew, "fsRename", cbs)) return;
+  _fs.rename(vOld.realPath, vNew.realPath, nodeComplete("fsRename", cbs));
 }
-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);
+function fsUnlink({ filePath, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  if (guardFsAvailable("fsUnlink", cbs)) return;
+  const v = resolveOrBail(filePath, "fsUnlink", cbs);
+  if (!v) return;
+  if (!ensureWritable(v, "fsUnlink", cbs)) return;
+  _fs.unlink(v.realPath, nodeComplete("fsUnlink", cbs));
 }
-
-// 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 fsMkdir({ dirPath, recursive = false, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  if (guardFsAvailable("fsMkdir", cbs)) return;
+  const v = resolveOrBail(dirPath, "fsMkdir", cbs);
+  if (!v) return;
+  if (!ensureWritable(v, "fsMkdir", cbs)) return;
+  _fs.mkdir(v.realPath, { recursive }, nodeComplete("fsMkdir", cbs));
 }
-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;
+function fsRmdir({ dirPath, recursive = false, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  if (guardFsAvailable("fsRmdir", cbs)) return;
+  const v = resolveOrBail(dirPath, "fsRmdir", cbs);
+  if (!v) return;
+  if (!ensureWritable(v, "fsRmdir", cbs)) return;
+  if (recursive) {
+    const rmFn = _fs.rm ?? _fs.rmdir;
+    rmFn(v.realPath, { recursive: true }, nodeComplete("fsRmdir", cbs));
   } else {
-    kind = "usr";
-    writable = true;
-  }
-  if (kind === "tmp") {
-    return { kind, writable };
+    _fs.rmdir(v.realPath, nodeComplete("fsRmdir", cbs));
   }
-  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);
-    return await blobToBuffer(blob);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`ENOENT: no such file (${url}): ${msg}`, { cause: err });
-  }
-}
-function isArrayBuffer(value) {
-  return Object.prototype.toString.call(value) === "[object ArrayBuffer]";
-}
-async function blobToBuffer(blob) {
-  const readable = blob;
-  if (typeof readable.arrayBuffer === "function") {
-    const ab = await readable.arrayBuffer();
-    return Buffer.from(new Uint8Array(ab));
+function fsReaddir({ dirPath, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsReaddir", cbs)) return;
+  const v = resolveOrBail(dirPath, "fsReaddir", cbs);
+  if (!v) return;
+  if (v.kind === "tmp" || v.kind === "store") {
+    onFail?.({ errMsg: `fsReaddir:fail ${v.kind} is a flat namespace (no dir tree)` });
+    onComplete?.();
+    return;
   }
-  if (typeof FileReader !== "function") {
-    throw new Error("Blob cannot be read as ArrayBuffer");
+  if (!v.realPath) {
+    onFail?.({ errMsg: "fsReaddir:fail invalid path" });
+    onComplete?.();
+    return;
   }
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onerror = () => reject(reader.error ?? new Error("Blob read failed"));
-    reader.onload = () => {
-      const result = reader.result;
-      if (!isArrayBuffer(result)) {
-        reject(new Error("Blob read did not return an ArrayBuffer"));
-        return;
-      }
-      resolve(Buffer.from(new Uint8Array(result)));
-    };
-    reader.readAsArrayBuffer(blob);
-  });
-}
-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 guardFsAvailable(apiName, cbs) {
-  if (_fs) return false;
-  cbs.onFail?.({ errMsg: `${apiName}:fail not available in browser context` });
-  cbs.onComplete?.();
-  return true;
-}
-function resolveOrBail(p, apiName, cbs) {
-  const v = resolveVPath(p);
-  if (v) return v;
-  cbs.onFail?.({ errMsg: `${apiName}:fail invalid or unsafe path` });
-  cbs.onComplete?.();
-  return void 0;
-}
-function ensureWritable(v, apiName, cbs) {
-  if (v.writable && v.realPath) return true;
-  cbs.onFail?.({ errMsg: `${apiName}:fail permission denied` });
-  cbs.onComplete?.();
-  return false;
-}
-function tmpFailHandler(apiName, cbs) {
-  return (err) => {
-    cbs.onFail?.({ errMsg: `${apiName}:fail ${err.message}` });
-    cbs.onComplete?.();
-  };
-}
-function nodeComplete(apiName, cbs, buildOk) {
-  return (err, ...args) => {
-    if (err) {
-      cbs.onFail?.({ errMsg: `${apiName}:fail ${err.message}` });
-    } else {
-      cbs.onSuccess?.({ ...buildOk ? buildOk(...args) : void 0, errMsg: `${apiName}:ok` });
-    }
-    cbs.onComplete?.();
-  };
-}
-function mkdirpThenWrite(destReal, apiName, cbs, writeFn, okExtra) {
-  _fs.mkdir(_path.dirname(destReal), { recursive: true }, (mkdirErr) => {
-    if (mkdirErr) {
-      cbs.onFail?.({ errMsg: `${apiName}:fail ${mkdirErr.message}` });
-      cbs.onComplete?.();
-      return;
-    }
-    writeFn(nodeComplete(apiName, cbs, () => okExtra));
-  });
+  _fs.readdir(v.realPath, nodeComplete("fsReaddir", cbs, (files) => ({ files })));
 }
-function fsAccess({ path: path2, success, fail, complete }) {
+function fsGetFileInfo({ filePath, digestAlgorithm, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
   const { onSuccess, onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsAccess", cbs)) return;
-  const v = resolveOrBail(path2, "fsAccess", cbs);
+  if (guardFsAvailable("fsGetFileInfo", cbs)) return;
+  const v = resolveOrBail(filePath, "fsGetFileInfo", cbs);
   if (!v) return;
+  const algorithm = digestAlgorithm === "sha1" ? "sha1" : "md5";
   if (v.kind === "tmp") {
-    _tmpBytes(path2).then(
-      () => {
-        onSuccess?.({ errMsg: "fsAccess:ok" });
-        onComplete?.();
+    _tmpBytes(filePath).then(
+      (buf) => {
+        try {
+          const hash = _crypto.createHash(algorithm);
+          hash.update(buf);
+          onSuccess?.({ size: buf.length, digest: hash.digest("hex"), errMsg: "fsGetFileInfo:ok" });
+          onComplete?.();
+        } catch (hashErr) {
+          onFail?.({ errMsg: `fsGetFileInfo:fail ${hashErr.message}` });
+          onComplete?.();
+        }
       },
-      tmpFailHandler("fsAccess", cbs)
+      tmpFailHandler("fsGetFileInfo", cbs)
     );
     return;
   }
   if (!v.realPath) {
-    onFail?.({ errMsg: "fsAccess:fail invalid path" });
+    onFail?.({ errMsg: "fsGetFileInfo:fail invalid path" });
     onComplete?.();
     return;
   }
-  _fs.access(v.realPath, _fs.constants.F_OK, nodeComplete("fsAccess", cbs));
-}
-function fsStat({ path: path2, recursive = false, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onSuccess, onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsStat", cbs)) return;
-  const v = resolveOrBail(path2, "fsStat", cbs);
-  if (!v) 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"
-        });
+  const resolved = v.realPath;
+  _fs.stat(resolved, (err, s) => {
+    if (err) {
+      onFail?.({ errMsg: `fsGetFileInfo:fail ${err.message}` });
+      onComplete?.();
+      return;
+    }
+    try {
+      const hash = _crypto.createHash(algorithm);
+      const stream = _fs.createReadStream(resolved);
+      stream.on("data", (chunk) => hash.update(chunk));
+      stream.on("end", () => {
+        onSuccess?.({ size: s.size, digest: hash.digest("hex"), errMsg: "fsGetFileInfo:ok" });
         onComplete?.();
-      },
-      tmpFailHandler("fsStat", cbs)
+      });
+      stream.on("error", (hashErr) => {
+        onFail?.({ errMsg: `fsGetFileInfo:fail ${hashErr.message}` });
+        onComplete?.();
+      });
+    } catch (hashErr) {
+      onFail?.({ errMsg: `fsGetFileInfo:fail ${hashErr.message}` });
+      onComplete?.();
+    }
+  });
+}
+function resolveSaveFileDestination(tempFilePath, filePath, cbs) {
+  if (typeof filePath === "string" && filePath) {
+    const dest = resolveOrBail(filePath, "fsSaveFile", cbs);
+    if (!dest) return void 0;
+    if (!ensureWritable(dest, "fsSaveFile", cbs)) return void 0;
+    return { savedFilePath: filePath, destReal: dest.realPath };
+  }
+  const ext = _path.extname(tempFilePath) || "";
+  const id = _crypto.randomUUID() + ext;
+  const savedFilePath = `difile://_store/${id}`;
+  const destResolved = resolveVPath(savedFilePath);
+  if (!destResolved || !destResolved.realPath) {
+    cbs.onFail?.({ errMsg: "fsSaveFile:fail unable to allocate destination" });
+    cbs.onComplete?.();
+    return void 0;
+  }
+  if (containsSymlink(destResolved.realPath)) {
+    cbs.onFail?.({ errMsg: "fsSaveFile:fail invalid or unsafe path" });
+    cbs.onComplete?.();
+    return void 0;
+  }
+  return { savedFilePath, destReal: destResolved.realPath };
+}
+function fsSaveFile({ tempFilePath, filePath, success, fail, complete }) {
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsSaveFile", cbs)) return;
+  const src = resolveOrBail(tempFilePath, "fsSaveFile", cbs);
+  if (!src) return;
+  const destination = resolveSaveFileDestination(tempFilePath, filePath, cbs);
+  if (!destination) return;
+  const { savedFilePath, destReal } = destination;
+  if (src.kind === "tmp") {
+    _tmpBytes(tempFilePath).then(
+      (bytes) => mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.writeFile(destReal, bytes, done), { savedFilePath }),
+      tmpFailHandler("fsSaveFile", cbs)
     );
     return;
   }
-  if (!v.realPath) {
-    onFail?.({ errMsg: "fsStat:fail invalid path" });
+  if (!src.realPath) {
+    onFail?.({ errMsg: "fsSaveFile:fail invalid src 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" });
+  if (src.realPath === destReal) {
+    _fs.stat(src.realPath, (statErr, st) => {
+      if (statErr) {
+        onFail?.({ errMsg: `fsSaveFile:fail ${statErr.message}` });
+        onComplete?.();
+        return;
+      }
+      if (!st.isFile()) {
+        onFail?.({ errMsg: `fsSaveFile:fail illegal operation on a directory, copyfile '${tempFilePath}'` });
+        onComplete?.();
+        return;
       }
+      cbs.onSuccess?.({ savedFilePath, errMsg: "fsSaveFile:ok" });
       onComplete?.();
     });
-  } else {
-    _fs.stat(resolved, nodeComplete("fsStat", cbs, (s) => ({
-      stats: {
-        size: s.size,
-        mode: s.mode,
-        lastAccessedTime: s.atimeMs,
-        lastModifiedTime: s.mtimeMs,
-        isFile: s.isFile(),
-        isDirectory: s.isDirectory()
-      }
-    })));
+    return;
   }
+  mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.copyFile(src.realPath, destReal, done), { savedFilePath });
 }
-function fsReadFile({ filePath, encoding, success, fail, complete }) {
+function fsGetSavedFileList({ success, fail, complete } = {}) {
   const cbs = bindCallbacks(this, { success, fail, complete });
   const { onSuccess, onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsReadFile", cbs)) return;
-  const v = resolveOrBail(filePath, "fsReadFile", cbs);
-  if (!v) return;
-  if (v.kind === "tmp") {
-    _tmpBytes(filePath).then(
-      (buf) => {
-        const data = encoding ? buf.toString(encoding) : buf;
-        onSuccess?.({ data, errMsg: "fsReadFile:ok" });
-        onComplete?.();
-      },
-      tmpFailHandler("fsReadFile", cbs)
-    );
-    return;
-  }
-  if (!v.realPath) {
-    onFail?.({ errMsg: "fsReadFile:fail invalid path" });
+  if (guardFsAvailable("fsGetSavedFileList", cbs)) return;
+  const storeVpath = resolveVPath("difile://_store/");
+  const storeDir = storeVpath?.realPath;
+  if (!storeDir) {
+    onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
     onComplete?.();
     return;
   }
-  _fs.readFile(v.realPath, encoding || null, nodeComplete("fsReadFile", cbs, (data) => ({ data })));
+  _fs.readdir(storeDir, (err, files) => {
+    if (err) {
+      if (err.code === "ENOENT") {
+        onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
+      } else {
+        onFail?.({ errMsg: `fsGetSavedFileList:fail ${err.message}` });
+      }
+      onComplete?.();
+      return;
+    }
+    let pending = files.length;
+    if (pending === 0) {
+      onSuccess?.({ fileList: [], errMsg: "fsGetSavedFileList:ok" });
+      onComplete?.();
+      return;
+    }
+    const fileList = [];
+    let settled = false;
+    for (const name of files) {
+      const full = _path.join(storeDir, name);
+      _fs.stat(full, (statErr, s) => {
+        if (settled) return;
+        if (statErr) {
+          settled = true;
+          onFail?.({ errMsg: `fsGetSavedFileList:fail ${statErr.message}` });
+          onComplete?.();
+          return;
+        }
+        fileList.push({
+          filePath: `difile://_store/${name}`,
+          size: s.size,
+          // wx createTime is a seconds-unit epoch.
+          createTime: Math.floor(s.birthtimeMs / 1e3)
+        });
+        if (--pending === 0) {
+          settled = true;
+          onSuccess?.({ fileList, errMsg: "fsGetSavedFileList:ok" });
+          onComplete?.();
+        }
+      });
+    }
+  });
 }
-function fsWriteFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
+function fsRemoveSavedFile({ filePath, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsWriteFile", cbs)) return;
-  const v = resolveOrBail(filePath, "fsWriteFile", cbs);
+  const { onFail, onComplete } = cbs;
+  if (guardFsAvailable("fsRemoveSavedFile", cbs)) return;
+  const v = resolveOrBail(filePath, "fsRemoveSavedFile", cbs);
   if (!v) return;
-  if (!ensureWritable(v, "fsWriteFile", cbs)) return;
-  mkdirpThenWrite(v.realPath, "fsWriteFile", cbs, (done) => _fs.writeFile(v.realPath, data, { encoding }, done));
+  if (v.kind !== "store" || !v.realPath) {
+    onFail?.({ errMsg: "fsRemoveSavedFile:fail only _store/ entries may be removed" });
+    onComplete?.();
+    return;
+  }
+  _fs.unlink(v.realPath, nodeComplete("fsRemoveSavedFile", cbs));
 }
-function fsAppendFile({ filePath, data, encoding = "utf8", success, fail, complete }) {
+function fsTruncate({ filePath, length = 0, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsAppendFile", cbs)) return;
-  const v = resolveOrBail(filePath, "fsAppendFile", cbs);
+  if (guardFsAvailable("fsTruncate", cbs)) return;
+  const v = resolveOrBail(filePath, "fsTruncate", cbs);
   if (!v) return;
-  if (!ensureWritable(v, "fsAppendFile", cbs)) return;
-  _fs.appendFile(v.realPath, data, { encoding }, nodeComplete("fsAppendFile", cbs));
+  if (!ensureWritable(v, "fsTruncate", cbs)) return;
+  _fs.truncate(v.realPath, length, nodeComplete("fsTruncate", cbs));
 }
-function fsCopyFile({ srcPath, destPath, success, fail, complete }) {
+function readVPathBytesSync(p) {
+  if (!_fs) return null;
+  const v = resolveVPath(p);
+  if (!v?.realPath) return null;
+  if (containsSymlink(v.realPath)) return null;
+  try {
+    return _fs.readFileSync(v.realPath);
+  } catch {
+    return null;
+  }
+}
+
+// src/simulator/simulator-api-media.ts
+function captureAttrFor(sourceType, camera) {
+  if (sourceType.length !== 1 || sourceType[0] !== "camera") return void 0;
+  return camera === "front" ? "user" : "environment";
+}
+function createFilePicker(apiName, config, cbs, onPick) {
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = config.accept;
+  input.multiple = config.multiple;
+  if (config.capture) input.setAttribute("capture", config.capture);
+  input.style.display = "none";
+  document.body.appendChild(input);
+  const removeInput = () => input.remove();
+  input.addEventListener("change", () => {
+    const files = Array.from(input.files || []);
+    if (files.length === 0) {
+      cbs.onFail?.({ errMsg: `${apiName}:fail cancel` });
+      cbs.onComplete?.();
+      removeInput();
+      return;
+    }
+    void onPick(files, removeInput);
+  });
+  input.click();
+}
+function chooseImage({ count = 9, sourceType, camera, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsCopyFile", cbs)) return;
-  const vSrc = resolveOrBail(srcPath, "fsCopyFile", cbs);
-  if (!vSrc) return;
-  const vDest = resolveOrBail(destPath, "fsCopyFile", cbs);
-  if (!vDest) return;
-  if (!ensureWritable(vDest, "fsCopyFile", cbs)) return;
-  if (vSrc.kind === "tmp") {
-    _tmpBytes(srcPath).then(
-      (buf) => mkdirpThenWrite(vDest.realPath, "fsCopyFile", cbs, (done) => _fs.writeFile(vDest.realPath, buf, done)),
-      tmpFailHandler("fsCopyFile", cbs)
+  const { onSuccess, onComplete } = cbs;
+  const normalizedCount = normalizeChooseMediaCount(count);
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  createFilePicker(
+    "chooseImage",
+    { accept: "image/*", multiple: normalizedCount > 1, capture: captureAttrFor(normalizedSourceType, camera) },
+    cbs,
+    (rawFiles, removeInput) => {
+      const files = rawFiles.slice(0, normalizedCount);
+      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?.();
+      removeInput();
+    }
+  );
+}
+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 });
+  const triggerDownload = (href) => {
+    const a = document.createElement("a");
+    a.href = href;
+    a.download = "image";
+    a.click();
+  };
+  if (typeof filePath === "string" && filePath.startsWith("difile://_tmp/")) {
+    resolveTempFilePath(filePath).then(
+      (blob) => new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => reject(reader.error ?? new Error("blob read failed"));
+        reader.onload = () => resolve(String(reader.result));
+        reader.readAsDataURL(blob);
+      })
+    ).then(
+      (href) => {
+        triggerDownload(href);
+        onSuccess?.({ errMsg: "saveImageToPhotosAlbum:ok" });
+        onComplete?.();
+      },
+      (err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        onFail?.({ errMsg: `saveImageToPhotosAlbum:fail ${msg}` });
+        onComplete?.();
+      }
     );
     return;
   }
-  if (!vSrc.realPath) {
-    onFail?.({ errMsg: "fsCopyFile:fail invalid src path" });
-    onComplete?.();
-    return;
+  try {
+    if (typeof filePath === "string" && filePath.startsWith("difile://")) {
+      const bytes = readVPathBytesSync(filePath);
+      if (bytes) {
+        triggerDownload(`data:application/octet-stream;base64,${bytes.toString("base64")}`);
+        onSuccess?.({ errMsg: "saveImageToPhotosAlbum:ok" });
+      } else {
+        onFail?.({ errMsg: "saveImageToPhotosAlbum:fail no such file" });
+      }
+    } else {
+      onFail?.({ errMsg: "saveImageToPhotosAlbum:fail invalid file path" });
+    }
+  } catch (error) {
+    onFail?.({ errMsg: `saveImageToPhotosAlbum:fail ${error.message}` });
   }
-  _fs.copyFile(vSrc.realPath, vDest.realPath, nodeComplete("fsCopyFile", cbs));
+  onComplete?.();
 }
-function fsRename({ oldPath, newPath, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsRename", cbs)) return;
-  const vOld = resolveOrBail(oldPath, "fsRename", cbs);
-  if (!vOld) return;
-  const vNew = resolveOrBail(newPath, "fsRename", cbs);
-  if (!vNew) return;
-  if (!ensureWritable(vOld, "fsRename", cbs)) return;
-  if (!ensureWritable(vNew, "fsRename", cbs)) return;
-  _fs.rename(vOld.realPath, vNew.realPath, nodeComplete("fsRename", cbs));
+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;
 }
-function fsUnlink({ filePath, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsUnlink", cbs)) return;
-  const v = resolveOrBail(filePath, "fsUnlink", cbs);
-  if (!v) return;
-  if (!ensureWritable(v, "fsUnlink", cbs)) return;
-  _fs.unlink(v.realPath, nodeComplete("fsUnlink", cbs));
+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 fsMkdir({ dirPath, recursive = false, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsMkdir", cbs)) return;
-  const v = resolveOrBail(dirPath, "fsMkdir", cbs);
-  if (!v) return;
-  if (!ensureWritable(v, "fsMkdir", cbs)) return;
-  _fs.mkdir(v.realPath, { recursive }, nodeComplete("fsMkdir", cbs));
+function normalizeChooseMediaCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 9;
+  return Math.max(1, Math.min(20, Math.floor(n)));
 }
-function fsRmdir({ dirPath, recursive = false, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsRmdir", cbs)) return;
-  const v = resolveOrBail(dirPath, "fsRmdir", cbs);
-  if (!v) return;
-  if (!ensureWritable(v, "fsRmdir", cbs)) return;
-  const rmFn = _fs.rm ?? _fs.rmdir;
-  rmFn(v.realPath, { recursive }, nodeComplete("fsRmdir", cbs));
+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 fsReaddir({ dirPath, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsReaddir", cbs)) return;
-  const v = resolveOrBail(dirPath, "fsReaddir", cbs);
-  if (!v) 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, nodeComplete("fsReaddir", cbs, (files) => ({ files })));
+function getChooseMediaResultType(files) {
+  const types = new Set(files.map((file) => file.fileType));
+  if (types.size > 1) return "mix";
+  return files[0]?.fileType ?? "image";
 }
-function fsGetFileInfo({ filePath, digestAlgorithm, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onSuccess, onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsGetFileInfo", cbs)) return;
-  const v = resolveOrBail(filePath, "fsGetFileInfo", cbs);
-  if (!v) return;
-  if (v.kind === "tmp") {
-    _tmpBytes(filePath).then(
-      (buf) => {
-        const result = { size: buf.length, errMsg: "fsGetFileInfo:ok" };
-        if (digestAlgorithm) {
+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 {
-            const hash = _crypto.createHash(digestAlgorithm === "md5" ? "md5" : "sha1");
-            hash.update(buf);
-            result.digest = hash.digest("hex");
+            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();
         }
-        onSuccess?.(result);
-        onComplete?.();
-      },
-      tmpFailHandler("fsGetFileInfo", cbs)
-    );
-    return;
-  }
-  if (!v.realPath) {
-    onFail?.({ errMsg: "fsGetFileInfo:fail invalid path" });
-    onComplete?.();
-    return;
+      });
+    };
+    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 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) {
+  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 cbs = bindCallbacks(this, { success, fail, complete });
+  const { onSuccess, onFail, onComplete } = cbs;
+  const normalizedCount = normalizeChooseMediaCount(count);
+  const normalizedMediaType = normalizeStringArray(mediaType, ["image", "video"]);
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  createFilePicker(
+    "chooseMedia",
+    {
+      accept: getChooseMediaAccept(normalizedMediaType),
+      multiple: normalizedCount > 1,
+      capture: captureAttrFor(normalizedSourceType, camera)
+    },
+    cbs,
+    async (rawFiles, removeInput) => {
+      const files = rawFiles.slice(0, normalizedCount);
       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?.();
+        const tempFiles2 = await Promise.all(files.map(buildChooseMediaTempFile));
+        onSuccess?.({
+          tempFiles: tempFiles2,
+          type: getChooseMediaResultType(tempFiles2),
+          failedCount: 0,
+          errMsg: "chooseMedia:ok"
         });
-        return;
-      } catch {
+      } catch (error) {
+        onFail?.({ errMsg: `chooseMedia:fail ${error.message}` });
+      } finally {
+        onComplete?.();
+        removeInput();
       }
     }
-    onSuccess?.(result);
-    onComplete?.();
-  });
-}
-function fsSaveFile({ tempFilePath, filePath: _filePath, success, fail, complete }) {
-  void _filePath;
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsSaveFile", cbs)) return;
-  const src = resolveOrBail(tempFilePath, "fsSaveFile", cbs);
-  if (!src) 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;
-  if (src.kind === "tmp") {
-    _tmpBytes(tempFilePath).then(
-      (bytes) => mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.writeFile(destReal, bytes, done), { savedFilePath }),
-      tmpFailHandler("fsSaveFile", cbs)
-    );
-    return;
-  }
-  if (!src.realPath) {
-    onFail?.({ errMsg: "fsSaveFile:fail invalid src path" });
-    onComplete?.();
-    return;
-  }
-  mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.copyFile(src.realPath, destReal, done), { savedFilePath });
+  );
 }
-function fsGetSavedFileList({ success, fail, complete } = {}) {
+function chooseVideo({ sourceType, camera, success, fail, complete }) {
   const cbs = bindCallbacks(this, { success, fail, complete });
   const { onSuccess, onComplete } = cbs;
-  if (guardFsAvailable("fsGetSavedFileList", cbs)) 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" });
+  const normalizedSourceType = normalizeStringArray(sourceType, ["album", "camera"]);
+  createFilePicker(
+    "chooseVideo",
+    { accept: "video/*", multiple: false, capture: captureAttrFor(normalizedSourceType, camera) },
+    cbs,
+    async (files, removeInput) => {
+      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?.();
-      return;
+      removeInput();
     }
-    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?.();
-        }
+  );
+}
+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 fsRemoveSavedFile({ filePath, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  const { onFail, onComplete } = cbs;
-  if (guardFsAvailable("fsRemoveSavedFile", cbs)) return;
-  const v = resolveOrBail(filePath, "fsRemoveSavedFile", cbs);
-  if (!v) return;
-  if (v.kind !== "store" || !v.realPath) {
-    onFail?.({ errMsg: "fsRemoveSavedFile:fail only _store/ entries may be removed" });
-    onComplete?.();
-    return;
+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/simulator/simulator-api-fsm.ts
+var ARRAY_BUFFER_BASE64_KEY = "__diminaArrayBufferBase64";
+var FILE_DATA_TYPE_KEY = "__diminaFileDataType";
+var FILE_DATA_BASE64_KEY = "__diminaFileDataBase64";
+var FSM_ADAPTERS = [
+  { short: "access", impl: fsAccess },
+  { short: "stat", impl: fsStat },
+  { short: "readFile", impl: fsReadFile, encodeReadResult: true },
+  { short: "writeFile", impl: fsWriteFile, decodeWriteData: true },
+  { short: "appendFile", impl: fsAppendFile, decodeWriteData: true },
+  { short: "copyFile", impl: fsCopyFile },
+  { short: "rename", impl: fsRename },
+  { short: "unlink", impl: fsUnlink },
+  { short: "mkdir", impl: fsMkdir },
+  { short: "rmdir", impl: fsRmdir },
+  { short: "readdir", impl: fsReaddir },
+  { short: "getFileInfo", impl: fsGetFileInfo },
+  { short: "saveFile", impl: fsSaveFile },
+  { short: "getSavedFileList", impl: fsGetSavedFileList },
+  { short: "removeSavedFile", impl: fsRemoveSavedFile },
+  { short: "truncate", impl: fsTruncate }
+];
+function legacyPrefix(short) {
+  return `fs${short[0].toUpperCase()}${short.slice(1)}`;
+}
+function renameErrMsg(payload, legacy, short) {
+  if (!payload || typeof payload !== "object") return payload;
+  const rec = payload;
+  if (typeof rec.errMsg === "string" && rec.errMsg.startsWith(`${legacy}:`)) {
+    return { ...rec, errMsg: `${short}:${rec.errMsg.slice(legacy.length + 1)}` };
   }
-  _fs.unlink(v.realPath, nodeComplete("fsRemoveSavedFile", cbs));
+  return payload;
+}
+var BufferImpl2 = getNodeBindings().buffer?.Buffer ?? (typeof Buffer !== "undefined" ? Buffer : void 0);
+function decodeFileData(data) {
+  if (!BufferImpl2) return data;
+  if (!data || typeof data !== "object") return data;
+  const rec = data;
+  if (rec[FILE_DATA_TYPE_KEY] !== "base64" || typeof rec[FILE_DATA_BASE64_KEY] !== "string") return data;
+  return BufferImpl2.from(rec[FILE_DATA_BASE64_KEY], "base64");
+}
+function encodeReadResult(payload) {
+  if (!BufferImpl2) return payload;
+  if (!payload || typeof payload !== "object") return payload;
+  const rec = payload;
+  const data = rec.data;
+  if (typeof data === "string" || !ArrayBuffer.isView(data)) return payload;
+  const bytes = BufferImpl2.from(data.buffer, data.byteOffset, data.byteLength);
+  return { ...rec, data: { [ARRAY_BUFFER_BASE64_KEY]: bytes.toString("base64") } };
+}
+function makeFsmHandler(spec) {
+  const legacy = legacyPrefix(spec.short);
+  return function(params) {
+    const raw = params && typeof params === "object" && !Array.isArray(params) ? { ...params } : {};
+    const { success, fail, complete, ...rest } = raw;
+    const cbs = bindCallbacks(this, { success, fail, complete });
+    const opts = rest;
+    if (spec.decodeWriteData && "data" in opts) {
+      opts.data = decodeFileData(opts.data);
+    }
+    let verdictFired = false;
+    let completeFired = false;
+    const fireSuccess = (out) => {
+      if (verdictFired) return;
+      verdictFired = true;
+      cbs.onSuccess?.(out);
+    };
+    const fireFail = (out) => {
+      if (verdictFired) return;
+      verdictFired = true;
+      cbs.onFail?.(out);
+    };
+    const fireComplete = () => {
+      if (completeFired) return;
+      completeFired = true;
+      cbs.onComplete?.();
+    };
+    opts.success = (res) => {
+      let out = renameErrMsg(res, legacy, spec.short);
+      if (spec.encodeReadResult) out = encodeReadResult(out);
+      fireSuccess(out);
+    };
+    opts.fail = (res) => {
+      fireFail(renameErrMsg(res, legacy, spec.short));
+    };
+    opts.complete = fireComplete;
+    const innerCtx = Object.create(this);
+    innerCtx.createCallbackFunction = (fn) => typeof fn === "function" ? fn : void 0;
+    try {
+      spec.impl.call(innerCtx, opts);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      fireFail({ errMsg: `${spec.short}:fail ${msg}` });
+      fireComplete();
+    }
+  };
 }
-function fsTruncate({ filePath, length = 0, success, fail, complete }) {
-  const cbs = bindCallbacks(this, { success, fail, complete });
-  if (guardFsAvailable("fsTruncate", cbs)) return;
-  const v = resolveOrBail(filePath, "fsTruncate", cbs);
-  if (!v) return;
-  if (!ensureWritable(v, "fsTruncate", cbs)) return;
-  _fs.truncate(v.realPath, length, nodeComplete("fsTruncate", cbs));
+var handlers = {};
+for (const spec of FSM_ADAPTERS) {
+  handlers[`FileSystemManager.${spec.short}`] = makeFsmHandler(spec);
+}
+var fileSystemManagerApis = handlers;
+
+// ../dimina-electron-runtime/dist/shared/request-core.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+var MAX_TIMEOUT_MS = 2147483647;
+function resolveTimeoutBudgetMs(timeout) {
+  const t = Number(timeout);
+  return Number.isFinite(t) && t > 0 && t <= MAX_TIMEOUT_MS ? t : DEFAULT_REQUEST_TIMEOUT_MS;
 }
-var fsUnzip = notSupportedApi("fsUnzip");
 
 // src/simulator/simulator-api-network.ts
-function downloadFile({ url, header = {}, filePath, success, fail, complete }) {
+function downloadFile({ url, header = {}, filePath, timeout, 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);
+  let settled = false;
+  const settleFail = (errMsg) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    onFail?.({ errMsg });
+    onComplete?.();
+  };
+  const settleOk = (result) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    onSuccess?.(result);
+    onComplete?.();
+  };
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    settleFail("downloadFile:fail timeout");
+    controller.abort();
+  }, resolveTimeoutBudgetMs(timeout));
+  fetch(url, { headers: header, signal: controller.signal }).then(async (response) => {
+    if (!response.ok) {
+      settleFail(
+        `downloadFile:fail HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`
+      );
+      return;
+    }
     const blob = await response.blob();
     const tempFilePath = createTempFilePath(blob);
-    onSuccess?.({
+    settleOk({
       tempFilePath,
       filePath: filePath || tempFilePath,
       statusCode: response.status,
       errMsg: "downloadFile:ok"
     });
   }).catch((error) => {
-    onFail?.({ errMsg: `downloadFile:fail ${error.message}` });
-  }).finally(() => {
-    onComplete?.();
+    settleFail(`downloadFile:fail ${error.message}`);
   });
 }
 var uploadRequests = /* @__PURE__ */ new Map();
@@ -1870,24 +2183,9 @@ var simulatorApis = {
   audioStop,
   audioSeek,
   audioDestroy,
-  // Filesystem (service-apis/file)
-  fsAccess,
-  fsStat,
-  fsReadFile,
-  fsWriteFile,
-  fsAppendFile,
-  fsCopyFile,
-  fsRename,
-  fsUnlink,
-  fsMkdir,
-  fsRmdir,
-  fsReaddir,
-  fsGetFileInfo,
-  fsSaveFile,
-  fsGetSavedFileList,
-  fsRemoveSavedFile,
-  fsTruncate,
-  fsUnzip
+  // Filesystem: the service thread invokes the dotted FileSystemManager.*
+  // wire names (see simulator-api-fsm.ts).
+  ...fileSystemManagerApis
 };
 
 // src/preload/windows/main.ts