@dimina-kit/devtools 0.4.0-dev.20260630094624 → 0.4.0-dev.20260701083540

package/dist/main/app/app.js

@@ -388,6 +388,12 @@ export async function createDevtoolsRuntime(config = {}) {
         registerSimulatorApi: (name, handler) => context.registry.add(toDisposable(context.simulatorApis.register(name, handler))),
         dispose: () => disposeContext(context),
     };
+    // Built-in simulator APIs: devtools-supplied wx.* implementations that run
+    // in the main process. Hosts can override any of these in their onSetup by
+    // re-registering the same name (last-write-wins on the Map).
+    instance.registerSimulatorApi('login', async () => {
+        return 'hello';
+    });
     if (config.onSetup) {
         await config.onSetup(instance);
     }

package/dist/main/index.bundle.js

@@ -5627,6 +5627,52 @@ function findSimulatorWebContents() {
   return null;
 }
 
+// src/main/ipc/page-scroll.ts
+function buildPageScrollScript(params) {
+  const rawTop = Number(params.scrollTop);
+  const top = Number.isFinite(rawTop) ? rawTop : 0;
+  const duration = params.duration === void 0 ? 300 : Number(params.duration);
+  const behavior = Number.isFinite(duration) && duration > 0 ? "smooth" : "auto";
+  return `window.scrollTo({ top: ${top}, left: 0, behavior: ${JSON.stringify(behavior)} })`;
+}
+
+// src/main/ipc/app-lifecycle.ts
+function createAppLifecycleController() {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    register(appSessionId, event, callbackId) {
+      if (callbackId === void 0 || callbackId === null) return;
+      let events = sessions.get(appSessionId);
+      if (!events) {
+        events = /* @__PURE__ */ new Map();
+        sessions.set(appSessionId, events);
+      }
+      let ids = events.get(event);
+      if (!ids) {
+        ids = /* @__PURE__ */ new Set();
+        events.set(event, ids);
+      }
+      ids.add(callbackId);
+    },
+    unregister(appSessionId, event, callbackId) {
+      const events = sessions.get(appSessionId);
+      if (!events) return;
+      if (callbackId === void 0 || callbackId === null) {
+        events.delete(event);
+        return;
+      }
+      events.get(event)?.delete(callbackId);
+    },
+    listeners(appSessionId, event) {
+      const ids = sessions.get(appSessionId)?.get(event);
+      return ids ? Array.from(ids) : [];
+    },
+    dispose(appSessionId) {
+      sessions.delete(appSessionId);
+    }
+  };
+}
+
 // src/main/ipc/bridge-router.ts
 function rewriteSourceMappingUrl(source, scriptUrl) {
   if (typeof source !== "string" || !source) return source;
@@ -5706,6 +5752,7 @@ function installBridgeRouter(ctx) {
     },
     connections: ctx.connections,
     debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
+    appLifecycle: createAppLifecycleController(),
     evictAppDataBridges: (ap) => {
       if (!ctx.appData) return;
       for (const page of ap.pages.values()) ctx.appData.evictBridge(ap.appId, page.bridgeId);
@@ -5723,6 +5770,7 @@ function installBridgeRouter(ctx) {
     ctx.registry.add(() => clearTimeout(warmTimer));
     ctx.registry.add(() => state.pool?.dispose());
   }
+  installAppLifecycleDriver(ctx, state);
   installResourceProtocolHandlers(ctx, state);
   let currentDevice = null;
   const onNativeHostQuery = (event) => {
@@ -6319,9 +6367,15 @@ function handleContainerMsg(ap, page, msg, ctx, state) {
     case "invokeAPI":
       void handleSimulatorApi(state, ap, page, msg.body, ctx);
       break;
-    case "serviceHostError":
+    case "serviceHostError": {
       console.warn("[bridge-router] service host error:", msg.body);
+      const errBody = msg.body;
+      const errArg = errBody?.message ?? msg.body;
+      for (const id of state.appLifecycle.listeners(ap.appSessionId, "onError")) {
+        sendCallback(ap, id, errArg);
+      }
       break;
+    }
     case "consoleLog":
       ctx.guestConsole?.emit(msg.body);
       break;
@@ -6353,6 +6407,40 @@ var TAB_ACTION_NAMES = /* @__PURE__ */ new Set([
   "showTabBarRedDot",
   "hideTabBarRedDot"
 ]);
+function installAppLifecycleDriver(ctx, state) {
+  const win = ctx.windows?.mainWindow;
+  if (!win || typeof win.on !== "function") return;
+  const emit = (serviceEvent, listenerEvent) => {
+    for (const ap of state.appSessions.values()) {
+      forwardToService(ap, { type: serviceEvent, target: "service", body: {} });
+      for (const id of state.appLifecycle.listeners(ap.appSessionId, listenerEvent)) {
+        sendCallback(ap, id, {});
+      }
+    }
+  };
+  const onHide = () => emit("appHide", "onAppHide");
+  const onShow = () => emit("appShow", "onAppShow");
+  win.on("hide", onHide);
+  win.on("minimize", onHide);
+  win.on("show", onShow);
+  win.on("restore", onShow);
+  ctx.registry.add(() => {
+    win.off("hide", onHide);
+    win.off("minimize", onHide);
+    win.off("show", onShow);
+    win.off("restore", onShow);
+  });
+}
+var APP_LIFECYCLE_REGISTER = {
+  onAppShow: "onAppShow",
+  onAppHide: "onAppHide",
+  onError: "onError"
+};
+var APP_LIFECYCLE_UNREGISTER = {
+  offAppShow: "onAppShow",
+  offAppHide: "onAppHide",
+  offError: "onError"
+};
 async function handleSimulatorApi(state, ap, page, body, ctx) {
   const name = String(body.name ?? "");
   const params = normalizeParams(body.params);
@@ -6403,6 +6491,27 @@ async function handleSimulatorApi(state, ap, page, body, ctx) {
     }
     return;
   }
+  const lifecycleRegister = APP_LIFECYCLE_REGISTER[name];
+  if (lifecycleRegister) {
+    state.appLifecycle.register(ap.appSessionId, lifecycleRegister, params.success);
+    return;
+  }
+  const lifecycleUnregister = APP_LIFECYCLE_UNREGISTER[name];
+  if (lifecycleUnregister) {
+    state.appLifecycle.unregister(ap.appSessionId, lifecycleUnregister, params.success);
+    return;
+  }
+  if (name === "pageScrollTo") {
+    const renderWc = page.renderWc;
+    if (renderWc && !renderWc.isDestroyed()) {
+      void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => {
+      });
+    }
+    const successResult = { errMsg: "pageScrollTo:ok" };
+    sendCallback(ap, params.success, successResult);
+    sendCallback(ap, params.complete, successResult);
+    return;
+  }
   if (ctx.storageApi && STORAGE_API_NAMES.has(name)) {
     try {
       const result = await ctx.storageApi.invoke(ap.appId, name, params);
@@ -6627,6 +6736,7 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
   const ap = state.appSessions.get(appSessionId);
   if (!ap) return;
   state.appSessions.delete(appSessionId);
+  state.appLifecycle.dispose(appSessionId);
   state.evictAppDataBridges(ap);
   for (const [requestId, pending] of state.pendingApiCalls) {
     if (pending.appSessionId !== appSessionId) continue;
@@ -10292,6 +10402,9 @@ async function createDevtoolsRuntime(config = {}) {
     registerSimulatorApi: (name, handler) => context.registry.add(toDisposable8(context.simulatorApis.register(name, handler))),
     dispose: () => disposeContext(context)
   };
+  instance.registerSimulatorApi("login", async () => {
+    return "hello";
+  });
   if (config.onSetup) {
     await config.onSetup(instance);
   }

package/dist/main/ipc/app-lifecycle.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Per-app-session registry for the app-level lifecycle listeners registered
+ * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
+ * (and their `off*` removers).
+ *
+ * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
+ * persistent callback id in `params.success` (service `callback.store(fn,
+ * keep=true)`), so the router stores the id here and re-fires it via
+ * `sendCallback` on every app foreground / background / error.
+ *
+ * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
+ * `callback.store` dedups by function and returns the original evtId, so `off*`
+ * carries that id and removes exactly that listener. `wx.offAppShow()` with no
+ * argument carries no id and clears every listener of the event (WeChat
+ * contract).
+ */
+export type AppLifecycleEvent = 'onAppShow' | 'onAppHide' | 'onError';
+export interface AppLifecycleController {
+    /** Store a keep callback id for an event. Null/undefined ids are ignored. */
+    register(appSessionId: string, event: AppLifecycleEvent, callbackId: unknown): void;
+    /**
+     * Remove a listener. With `callbackId`, removes only that id; without one,
+     * clears every listener of the event for the session.
+     */
+    unregister(appSessionId: string, event: AppLifecycleEvent, callbackId?: unknown): void;
+    /** Snapshot of the registered callback ids (empty for unknown session/event). */
+    listeners(appSessionId: string, event: AppLifecycleEvent): unknown[];
+    /** Drop all listeners for a torn-down session. */
+    dispose(appSessionId: string): void;
+}
+export declare function createAppLifecycleController(): AppLifecycleController;
+//# sourceMappingURL=app-lifecycle.d.ts.map

package/dist/main/ipc/app-lifecycle.js

@@ -0,0 +1,54 @@
+/**
+ * Per-app-session registry for the app-level lifecycle listeners registered
+ * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
+ * (and their `off*` removers).
+ *
+ * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
+ * persistent callback id in `params.success` (service `callback.store(fn,
+ * keep=true)`), so the router stores the id here and re-fires it via
+ * `sendCallback` on every app foreground / background / error.
+ *
+ * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
+ * `callback.store` dedups by function and returns the original evtId, so `off*`
+ * carries that id and removes exactly that listener. `wx.offAppShow()` with no
+ * argument carries no id and clears every listener of the event (WeChat
+ * contract).
+ */
+export function createAppLifecycleController() {
+    const sessions = new Map();
+    return {
+        register(appSessionId, event, callbackId) {
+            if (callbackId === undefined || callbackId === null)
+                return;
+            let events = sessions.get(appSessionId);
+            if (!events) {
+                events = new Map();
+                sessions.set(appSessionId, events);
+            }
+            let ids = events.get(event);
+            if (!ids) {
+                ids = new Set();
+                events.set(event, ids);
+            }
+            ids.add(callbackId);
+        },
+        unregister(appSessionId, event, callbackId) {
+            const events = sessions.get(appSessionId);
+            if (!events)
+                return;
+            if (callbackId === undefined || callbackId === null) {
+                events.delete(event);
+                return;
+            }
+            events.get(event)?.delete(callbackId);
+        },
+        listeners(appSessionId, event) {
+            const ids = sessions.get(appSessionId)?.get(event);
+            return ids ? Array.from(ids) : [];
+        },
+        dispose(appSessionId) {
+            sessions.delete(appSessionId);
+        },
+    };
+}
+//# sourceMappingURL=app-lifecycle.js.map

package/dist/main/ipc/bridge-router.js

@@ -11,6 +11,8 @@ import { ServiceHostPool } from '../services/service-host-pool/pool.js';
 import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from '../services/views/miniapp-partition.js';
 import { createConsoleForwarder } from '../services/console-forward/index.js';
 import { STORAGE_API_NAMES } from '../services/simulator-storage/index.js';
+import { buildPageScrollScript } from './page-scroll.js';
+import { createAppLifecycleController, } from './app-lifecycle.js';
 // The compiled `logic.js` ships a RELATIVE `//# sourceMappingURL=logic.js.map`.
 // `injectLogicBundle` loads it via `executeJavaScript`, which gives the injected
 // script no base URL of its own — so DevTools resolves that relative map against
@@ -152,6 +154,7 @@ export function installBridgeRouter(ctx) {
         emitRenderEvent: () => { },
         connections: ctx.connections,
         debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
+        appLifecycle: createAppLifecycleController(),
         evictAppDataBridges: (ap) => {
             if (!ctx.appData)
                 return;
@@ -180,6 +183,7 @@ export function installBridgeRouter(ctx) {
         ctx.registry.add(() => clearTimeout(warmTimer));
         ctx.registry.add(() => state.pool?.dispose());
     }
+    installAppLifecycleDriver(ctx, state);
     installResourceProtocolHandlers(ctx, state);
     // The currently-selected device (renderer toolbar). Cached here so it can ride
     // the NATIVE_HOST_ENABLED reply (race-free DeviceShell init) and so the
@@ -951,9 +955,20 @@ function handleContainerMsg(ap, page, msg, ctx, state) {
         case 'invokeAPI':
             void handleSimulatorApi(state, ap, page, msg.body, ctx);
             break;
-        case 'serviceHostError':
+        case 'serviceHostError': {
             console.warn('[bridge-router] service host error:', msg.body);
+            // Forward the error to every registered `wx.onError` listener. (The dimina
+            // service runtime's App lifecycle is only onLaunch/onShow/onHide, so it
+            // does not dispatch `App.onError` — `wx.onError` is the supported path.)
+            // The service preload's `deliver` try/catch already reports errors thrown
+            // during lifecycle/event dispatch here.
+            const errBody = msg.body;
+            const errArg = errBody?.message ?? msg.body;
+            for (const id of state.appLifecycle.listeners(ap.appSessionId, 'onError')) {
+                sendCallback(ap, id, errArg);
+            }
             break;
+        }
         case 'consoleLog':
             // Native-host console capture: the render-host / service-host guest preloads
             // monkeypatch console.* and post each entry here (one case handles both —
@@ -991,6 +1006,54 @@ const TAB_ACTION_NAMES = new Set([
     'showTabBarRedDot',
     'hideTabBarRedDot',
 ]);
+/**
+ * Drive app foreground/background from the main window's visibility. Minimizing
+ * or hiding the window backgrounds the mini-program (App.onHide + wx.onAppHide);
+ * restoring or showing it foregrounds it (App.onShow + wx.onAppShow). Focus/blur
+ * is deliberately NOT used — clicking a DevTools panel would falsely fire it.
+ * The initial App.onShow fires once at spawn (service `invokeSomeLifecycle`), so
+ * the driver only handles subsequent transitions.
+ */
+function installAppLifecycleDriver(ctx, state) {
+    const win = ctx.windows?.mainWindow;
+    // Guard against a headless/stub mainWindow (unit tests) that isn't a real
+    // event-emitting BrowserWindow.
+    if (!win || typeof win.on !== 'function')
+        return;
+    const emit = (serviceEvent, listenerEvent) => {
+        for (const ap of state.appSessions.values()) {
+            // App.onShow / onHide: the service runtime already listens for these.
+            forwardToService(ap, { type: serviceEvent, target: 'service', body: {} });
+            // wx.onAppShow / onAppHide imperative listeners.
+            for (const id of state.appLifecycle.listeners(ap.appSessionId, listenerEvent)) {
+                sendCallback(ap, id, {});
+            }
+        }
+    };
+    const onHide = () => emit('appHide', 'onAppHide');
+    const onShow = () => emit('appShow', 'onAppShow');
+    win.on('hide', onHide);
+    win.on('minimize', onHide);
+    win.on('show', onShow);
+    win.on('restore', onShow);
+    ctx.registry.add(() => {
+        win.off('hide', onHide);
+        win.off('minimize', onHide);
+        win.off('show', onShow);
+        win.off('restore', onShow);
+    });
+}
+// wx app-event API name → the lifecycle event whose listeners it (de)registers.
+const APP_LIFECYCLE_REGISTER = {
+    onAppShow: 'onAppShow',
+    onAppHide: 'onAppHide',
+    onError: 'onError',
+};
+const APP_LIFECYCLE_UNREGISTER = {
+    offAppShow: 'onAppShow',
+    offAppHide: 'onAppHide',
+    offError: 'onError',
+};
 async function handleSimulatorApi(state, ap, page, body, ctx) {
     const name = String(body.name ?? '');
     const params = normalizeParams(body.params);
@@ -1043,6 +1106,36 @@ async function handleSimulatorApi(state, ap, page, body, ctx) {
         }
         return;
     }
+    // App-level lifecycle listeners (wx.onAppShow / onAppHide / onError + off*).
+    // The service encodes the listener as a keep callback id in `params.success`;
+    // we store it and re-fire on main-window foreground/background (the driver in
+    // installBridgeRouter) and on serviceHostError. `off*` clears the event's
+    // listeners for the session.
+    const lifecycleRegister = APP_LIFECYCLE_REGISTER[name];
+    if (lifecycleRegister) {
+        state.appLifecycle.register(ap.appSessionId, lifecycleRegister, params.success);
+        return;
+    }
+    const lifecycleUnregister = APP_LIFECYCLE_UNREGISTER[name];
+    if (lifecycleUnregister) {
+        // off(cb) carries the same evtId as the original on(cb) → removes just that
+        // listener; off() with no callback carries no id → clears the whole event.
+        state.appLifecycle.unregister(ap.appSessionId, lifecycleUnregister, params.success);
+        return;
+    }
+    // pageScrollTo acts on the page's render guest (scroll its document), which
+    // only the main process can reach — run the scroll script in the invoking
+    // page's render webContents rather than forwarding to the simulator.
+    if (name === 'pageScrollTo') {
+        const renderWc = page.renderWc;
+        if (renderWc && !renderWc.isDestroyed()) {
+            void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => { });
+        }
+        const successResult = { errMsg: 'pageScrollTo:ok' };
+        sendCallback(ap, params.success, successResult);
+        sendCallback(ap, params.complete, successResult);
+        return;
+    }
     // Native-host storage unification: route async wx.setStorage/getStorage/etc.
     // to the service-host window's file:// store (the same store the *Sync APIs +
     // the Storage panel use), instead of forwarding to the simulator guest's
@@ -1335,6 +1428,7 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     if (!ap)
         return;
     state.appSessions.delete(appSessionId);
+    state.appLifecycle.dispose(appSessionId);
     // Evict AppData bridges FIRST — eviction enumerates `ap.pages`, which the
     // page teardown below progressively empties (and finally clears).
     state.evictAppDataBridges(ap);

package/dist/main/ipc/page-scroll.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
+ *
+ * The mini-program page scrolls the whole render document (the native iOS impl
+ * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
+ * simulator scrolls `window`. `duration` is best-effort: a positive duration
+ * maps to smooth scrolling (the browser owns the easing — the exact ms is not
+ * controllable), and `0` jumps instantly.
+ */
+export declare function buildPageScrollScript(params: {
+    scrollTop?: unknown;
+    duration?: unknown;
+}): string;
+//# sourceMappingURL=page-scroll.d.ts.map

package/dist/main/ipc/page-scroll.js

@@ -0,0 +1,17 @@
+/**
+ * Build the script that `wx.pageScrollTo` runs inside the page's render guest.
+ *
+ * The mini-program page scrolls the whole render document (the native iOS impl
+ * scrolls the WKWebView's scrollView; Android scrolls the page view), so the
+ * simulator scrolls `window`. `duration` is best-effort: a positive duration
+ * maps to smooth scrolling (the browser owns the easing — the exact ms is not
+ * controllable), and `0` jumps instantly.
+ */
+export function buildPageScrollScript(params) {
+    const rawTop = Number(params.scrollTop);
+    const top = Number.isFinite(rawTop) ? rawTop : 0;
+    const duration = params.duration === undefined ? 300 : Number(params.duration);
+    const behavior = Number.isFinite(duration) && duration > 0 ? 'smooth' : 'auto';
+    return `window.scrollTo({ top: ${top}, left: 0, behavior: ${JSON.stringify(behavior)} })`;
+}
+//# sourceMappingURL=page-scroll.js.map

package/dist/preload/windows/main.cjs

@@ -327,6 +327,68 @@ function vibrateLong({ success, complete } = {}) {
   onComplete?.();
 }
 var scanCode = notSupportedApi("scanCode");
+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?.();
+    }
+  );
+}
+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 navigator.clipboard.writeText(data).then(
+    () => {
+      onSuccess?.({ errMsg: "setClipboardData:ok" });
+      onComplete?.();
+    },
+    (error) => {
+      onFail?.({ errMsg: `setClipboardData:fail ${error?.message ?? error}` });
+      onComplete?.();
+    }
+  );
+}
+function mapEffectiveType(effectiveType) {
+  switch (effectiveType) {
+    case "4g":
+      return "4g";
+    case "3g":
+      return "3g";
+    case "2g":
+    case "slow-2g":
+      return "2g";
+    default:
+      return "unknown";
+  }
+}
+function resolveNetworkType(info) {
+  if (!info.onLine) return "none";
+  if (info.type === "wifi" || info.type === "ethernet") return "wifi";
+  if (info.type === "cellular") return mapEffectiveType(info.effectiveType);
+  if (info.effectiveType) return mapEffectiveType(info.effectiveType);
+  return "wifi";
+}
+function getNetworkType({ success, complete } = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
+  const connection = navigator.connection;
+  const networkType = resolveNetworkType({
+    onLine: navigator.onLine,
+    type: connection?.type,
+    effectiveType: connection?.effectiveType
+  });
+  onSuccess?.({ networkType, errMsg: "getNetworkType:ok" });
+  onComplete?.();
+}
 
 // src/simulator/event-bridge.ts
 function bindDomEvents(target, eventMap, fire, buildPayload) {
@@ -1754,6 +1816,134 @@ function uploadFileAbort({ uploadId } = {}) {
   }
 }
 
+// src/simulator/ui-overlay-bus.ts
+var UiOverlayBus = class {
+  state = { toast: null, dialog: null };
+  listeners = /* @__PURE__ */ new Set();
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  showToast(toast) {
+    this.set({ ...this.state, toast });
+  }
+  hideToast() {
+    this.set({ ...this.state, toast: null });
+  }
+  /**
+   * Clear `toast` only if it is still the active one. The toast auto-dismiss
+   * timer holds a reference to the toast it scheduled; a newer showToast may
+   * have replaced it in the meantime, and a blind `hideToast()` from the stale
+   * timer would wrongly clear the new toast.
+   */
+  dismissToast(toast) {
+    if (this.state.toast === toast) this.hideToast();
+  }
+  showDialog(dialog) {
+    this.set({ ...this.state, dialog });
+  }
+  hideDialog() {
+    this.set({ ...this.state, dialog: null });
+  }
+  set(next) {
+    this.state = next;
+    for (const listener of this.listeners) listener(next);
+  }
+};
+var uiOverlayBus = new UiOverlayBus();
+
+// src/simulator/simulator-api-ui.ts
+function showToast(opts = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, opts);
+  uiOverlayBus.showToast({
+    title: opts.title ?? "",
+    icon: opts.icon ?? "success",
+    image: opts.image,
+    duration: opts.duration ?? 1500,
+    mask: opts.mask ?? false
+  });
+  onSuccess?.({ errMsg: "showToast:ok" });
+  onComplete?.();
+}
+function hideToast(opts = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, opts);
+  uiOverlayBus.hideToast();
+  onSuccess?.({ errMsg: "hideToast:ok" });
+  onComplete?.();
+}
+function showLoading(opts = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, opts);
+  uiOverlayBus.showToast({
+    title: opts.title ?? "",
+    icon: "loading",
+    duration: Infinity,
+    mask: opts.mask ?? false
+  });
+  onSuccess?.({ errMsg: "showLoading:ok" });
+  onComplete?.();
+}
+function hideLoading(opts = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, opts);
+  uiOverlayBus.hideToast();
+  onSuccess?.({ errMsg: "hideLoading:ok" });
+  onComplete?.();
+}
+function showModal(opts = {}) {
+  const { onSuccess, onComplete } = bindCallbacks(this, opts);
+  const editable = opts.editable ?? false;
+  let settled = false;
+  uiOverlayBus.showDialog({
+    kind: "modal",
+    title: opts.title ?? "",
+    content: opts.content ?? "",
+    showCancel: opts.showCancel ?? true,
+    cancelText: opts.cancelText ?? "\u53D6\u6D88",
+    cancelColor: opts.cancelColor ?? "#000000",
+    confirmText: opts.confirmText ?? "\u786E\u5B9A",
+    confirmColor: opts.confirmColor ?? "#576B95",
+    editable,
+    placeholderText: opts.placeholderText ?? "",
+    onResult: (confirmed, content) => {
+      if (settled) return;
+      settled = true;
+      uiOverlayBus.hideDialog();
+      const result = {
+        confirm: confirmed,
+        cancel: !confirmed,
+        errMsg: "showModal:ok"
+      };
+      if (editable) result.content = content ?? "";
+      onSuccess?.(result);
+      onComplete?.();
+    }
+  });
+}
+function showActionSheet(opts = {}) {
+  const { onSuccess, onFail, onComplete } = bindCallbacks(this, opts);
+  let settled = false;
+  uiOverlayBus.showDialog({
+    kind: "actionSheet",
+    itemList: opts.itemList ?? [],
+    itemColor: opts.itemColor ?? "#000000",
+    onSelect: (index) => {
+      if (settled) return;
+      settled = true;
+      uiOverlayBus.hideDialog();
+      if (index === -1) {
+        onFail?.({ errMsg: "showActionSheet:fail cancel" });
+      } else {
+        onSuccess?.({ tapIndex: index, errMsg: "showActionSheet:ok" });
+      }
+      onComplete?.();
+    }
+  });
+}
+
 // src/simulator/simulator-api.ts
 function canIUse({ success, complete }) {
   const { onSuccess, onComplete } = bindCallbacks(this, { success, complete });
@@ -1872,6 +2062,13 @@ var simulatorApis = {
   getSystemInfoSync,
   getWindowInfo,
   getSystemSetting,
+  // UI: interaction
+  showToast,
+  hideToast,
+  showLoading,
+  hideLoading,
+  showModal,
+  showActionSheet,
   // Network
   downloadFile,
   uploadFile,
@@ -1899,6 +2096,9 @@ var simulatorApis = {
   vibrateShort,
   vibrateLong,
   scanCode,
+  getClipboardData,
+  setClipboardData,
+  getNetworkType,
   // Media: Image
   chooseImage,
   previewImage,