@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703051110

package/dist/preload/windows/main.cjs

@@ -185,54 +185,64 @@ function notSupportedApi(apiName) {
 }
 
 // src/simulator/simulator-api-storage.ts
-function setStorageSync({ key, data }) {
-  const storageKey = `${this.appId}_${key}`;
+function storageKeyOf(appId, key) {
+  return `${appId}_${key}`;
+}
+function collectAppKeys(appId) {
+  const prefix = `${appId}_`;
+  const keys = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (k && k.startsWith(prefix)) keys.push(k);
+  }
+  return keys;
+}
+function writeEntry(appId, key, data) {
   const dataString = typeof data === "object" ? JSON.stringify(data) : String(data);
-  localStorage.setItem(storageKey, dataString);
+  localStorage.setItem(storageKeyOf(appId, key), dataString);
 }
-function getStorageSync({ key }) {
-  const storageKey = `${this.appId}_${key}`;
-  const raw = localStorage.getItem(storageKey);
-  if (raw === null) return { data: "" };
+function readEntry(appId, key) {
+  const raw = localStorage.getItem(storageKeyOf(appId, key));
+  if (raw === null) return void 0;
   try {
     return { data: JSON.parse(raw) };
   } catch {
     return { data: raw };
   }
 }
-function removeStorageSync({ key }) {
-  const storageKey = `${this.appId}_${key}`;
-  localStorage.removeItem(storageKey);
+function clearAppKeys(appId) {
+  collectAppKeys(appId).forEach((k) => localStorage.removeItem(k));
 }
-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}_`;
+function storageInfoOf(appId) {
+  const prefix = `${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;
-    }
+  for (const fullKey of collectAppKeys(appId)) {
+    keys.push(fullKey.slice(prefix.length));
+    const item = localStorage.getItem(fullKey);
+    currentSize += item ? item.length * 2 : 0;
   }
   return { keys, currentSize, limitSize: 10 * 1024 * 1024 };
 }
+function setStorageSync({ key, data }) {
+  writeEntry(this.appId, key, data);
+}
+function getStorageSync({ key }) {
+  return readEntry(this.appId, key) ?? { data: "" };
+}
+function removeStorageSync({ key }) {
+  localStorage.removeItem(storageKeyOf(this.appId, key));
+}
+function clearStorageSync() {
+  clearAppKeys(this.appId);
+}
+function getStorageInfoSync() {
+  return storageInfoOf(this.appId);
+}
 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);
+    writeEntry(this.appId, key, data);
     onSuccess?.({ errMsg: "setStorage:ok" });
   } catch (e) {
     onFail?.({ errMsg: `setStorage:fail ${e.message}` });
@@ -241,26 +251,18 @@ function setStorage({ key, data, success, fail, complete }) {
 }
 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) {
+  const entry = readEntry(this.appId, key);
+  if (!entry) {
     onFail?.({ errMsg: "getStorage:fail data not found" });
   } else {
-    let data;
-    try {
-      data = JSON.parse(raw);
-    } catch {
-      data = raw;
-    }
-    onSuccess?.({ data, errMsg: "getStorage:ok" });
+    onSuccess?.({ data: entry.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);
+    localStorage.removeItem(storageKeyOf(this.appId, key));
     onSuccess?.({ errMsg: "removeStorage:ok" });
   } catch (e) {
     onFail?.({ errMsg: `removeStorage:fail ${e.message}` });
@@ -269,30 +271,14 @@ function removeStorage({ key, success, fail, complete }) {
 }
 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));
+  clearAppKeys(this.appId);
   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" });
+  const info = storageInfoOf(this.appId);
+  onSuccess?.({ ...info, errMsg: "getStorageInfo:ok" });
   onComplete?.();
 }
 
@@ -457,35 +443,50 @@ function getTempFileName(path2, blob, fallback = "file") {
 }
 
 // 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"]);
+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 = "image/*";
-  input.multiple = normalizedCount > 1;
-  if (normalizedSourceType.length === 1 && normalizedSourceType[0] === "camera") {
-    input.setAttribute("capture", camera === "front" ? "user" : "environment");
-  }
+  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 || []).slice(0, normalizedCount);
+    const files = Array.from(input.files || []);
     if (files.length === 0) {
-      onFail?.({ errMsg: "chooseImage:fail cancel" });
-      onComplete?.();
-      input.remove();
+      cbs.onFail?.({ errMsg: `${apiName}:fail cancel` });
+      cbs.onComplete?.();
+      removeInput();
       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();
+    void onPick(files, removeInput);
   });
   input.click();
 }
+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();
+    }
+  );
+}
 function previewImage({ urls, current, success, complete }) {
   const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
   if (!urls || urls.length === 0) {
@@ -726,78 +727,62 @@ async function buildChooseMediaTempFile(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 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"]);
-  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();
+  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 {
+        onComplete?.();
+        removeInput();
+      }
     }
-  });
-  input.click();
+  );
 }
 function chooseVideo({ sourceType, camera, success, fail, complete }) {
-  const { onSuccess, onFail, onComplete } = bindCallbacks(this, { success, fail, complete });
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  const { onSuccess, onComplete } = cbs;
   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" });
+  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?.();
-      input.remove();
-      return;
+      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?.();
-    input.remove();
-  });
-  input.click();
+  );
 }
 var AUDIO_EVENT_MAP = {
   play: "play",
@@ -966,39 +951,64 @@ async function _tmpBytes(url) {
 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) {
+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) {
-    onFail?.({ errMsg: `${apiName}:fail invalid or unsafe path` });
-    return null;
-  }
-  return v;
+  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 _denyWrite(apiName, onFail) {
-  onFail?.({ errMsg: `${apiName}:fail permission denied` });
+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));
+  });
 }
 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;
-  }
+  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?.();
       },
-      (err) => {
-        onFail?.({ errMsg: `fsAccess:fail ${err.message}` });
-        onComplete?.();
-      }
+      tmpFailHandler("fsAccess", cbs)
     );
     return;
   }
@@ -1007,27 +1017,14 @@ function fsAccess({ path: path2, success, fail, complete }) {
     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?.();
-  });
+  _fs.access(v.realPath, _fs.constants.F_OK, nodeComplete("fsAccess", cbs));
 }
 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;
-  }
+  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) => {
@@ -1044,10 +1041,7 @@ function fsStat({ path: path2, recursive = false, success, fail, complete }) {
         });
         onComplete?.();
       },
-      (err) => {
-        onFail?.({ errMsg: `fsStat:fail ${err.message}` });
-        onComplete?.();
-      }
+      tmpFailHandler("fsStat", cbs)
     );
     return;
   }
@@ -1103,38 +1097,24 @@ function fsStat({ path: path2, recursive = false, success, fail, complete }) {
       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"
-        });
+    _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()
       }
-      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;
-  }
+  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) => {
@@ -1142,10 +1122,7 @@ function fsReadFile({ filePath, encoding, success, fail, complete }) {
         onSuccess?.({ data, errMsg: "fsReadFile:ok" });
         onComplete?.();
       },
-      (err) => {
-        onFail?.({ errMsg: `fsReadFile:fail ${err.message}` });
-        onComplete?.();
-      }
+      tmpFailHandler("fsReadFile", cbs)
     );
     return;
   }
@@ -1154,116 +1131,37 @@ function fsReadFile({ filePath, encoding, success, fail, complete }) {
     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?.();
-  });
+  _fs.readFile(v.realPath, encoding || null, nodeComplete("fsReadFile", cbs, (data) => ({ data })));
 }
 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?.();
-    });
-  });
+  const cbs = bindCallbacks(this, { success, fail, complete });
+  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 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?.();
-  });
+  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 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;
-  }
+  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) => {
-        _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?.();
-      }
+      (buf) => mkdirpThenWrite(vDest.realPath, "fsCopyFile", cbs, (done) => _fs.writeFile(vDest.realPath, buf, done)),
+      tmpFailHandler("fsCopyFile", cbs)
     );
     return;
   }
@@ -1272,142 +1170,50 @@ function fsCopyFile({ srcPath, destPath, success, fail, complete }) {
     onComplete?.();
     return;
   }
-  _fs.copyFile(vSrc.realPath, vDest.realPath, (err) => {
-    if (err) {
-      onFail?.({ errMsg: `fsCopyFile:fail ${err.message}` });
-    } else {
-      onSuccess?.({ errMsg: "fsCopyFile:ok" });
-    }
-    onComplete?.();
-  });
+  _fs.copyFile(vSrc.realPath, vDest.realPath, nodeComplete("fsCopyFile", cbs));
 }
 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?.();
-  });
+  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 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?.();
-  });
+  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));
 }
 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?.();
-  });
+  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 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 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 }, (err) => {
-    if (err) {
-      onFail?.({ errMsg: `fsRmdir:fail ${err.message}` });
-    } else {
-      onSuccess?.({ errMsg: "fsRmdir:ok" });
-    }
-    onComplete?.();
-  });
+  rmFn(v.realPath, { recursive }, nodeComplete("fsRmdir", cbs));
 }
 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;
-  }
+  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?.();
@@ -1418,27 +1224,14 @@ function fsReaddir({ dirPath, success, fail, complete }) {
     onComplete?.();
     return;
   }
-  _fs.readdir(v.realPath, (err, files) => {
-    if (err) {
-      onFail?.({ errMsg: `fsReaddir:fail ${err.message}` });
-    } else {
-      onSuccess?.({ files, errMsg: "fsReaddir:ok" });
-    }
-    onComplete?.();
-  });
+  _fs.readdir(v.realPath, nodeComplete("fsReaddir", cbs, (files) => ({ files })));
 }
 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;
-  }
+  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) => {
@@ -1454,10 +1247,7 @@ function fsGetFileInfo({ filePath, digestAlgorithm, success, fail, complete }) {
         onSuccess?.(result);
         onComplete?.();
       },
-      (err) => {
-        onFail?.({ errMsg: `fsGetFileInfo:fail ${err.message}` });
-        onComplete?.();
-      }
+      tmpFailHandler("fsGetFileInfo", cbs)
     );
     return;
   }
@@ -1498,17 +1288,11 @@ function fsGetFileInfo({ filePath, digestAlgorithm, success, fail, complete }) {
 }
 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 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}`;
@@ -1519,27 +1303,10 @@ function fsSaveFile({ tempFilePath, filePath: _filePath, success, fail, complete
     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?.();
-      }
+      (bytes) => mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.writeFile(destReal, bytes, done), { savedFilePath }),
+      tmpFailHandler("fsSaveFile", cbs)
     );
     return;
   }
@@ -1548,29 +1315,12 @@ function fsSaveFile({ tempFilePath, filePath: _filePath, success, fail, complete
     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?.();
-    });
-  });
+  mkdirpThenWrite(destReal, "fsSaveFile", cbs, (done) => _fs.copyFile(src.realPath, destReal, done), { savedFilePath });
 }
 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 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) {
@@ -1610,56 +1360,25 @@ function fsGetSavedFileList({ success, fail, complete } = {}) {
   });
 }
 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;
-  }
+  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;
   }
-  _fs.unlink(v.realPath, (err) => {
-    if (err) {
-      onFail?.({ errMsg: `fsRemoveSavedFile:fail ${err.message}` });
-    } else {
-      onSuccess?.({ errMsg: "fsRemoveSavedFile:ok" });
-    }
-    onComplete?.();
-  });
+  _fs.unlink(v.realPath, nodeComplete("fsRemoveSavedFile", cbs));
 }
 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?.();
-  });
+  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 fsUnzip = notSupportedApi("fsUnzip");