@dimina-kit/devtools 0.4.0-dev.20260630070008 → 0.4.0-dev.20260630123203

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
@@ -490,6 +494,11 @@ async function handleSpawn(state, ctx, event, opts) {
         : '';
     const pkgRoot = path.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
     const root = opts.root || 'main';
+    // Host-config custom API namespaces (WorkbenchContext is the single owner).
+    // Threaded into the service-host spawn URL so its preload can install the
+    // namespace globals; the simulator-supplied `opts.apiNamespaces` is derived
+    // from the same host config and is not authoritative here.
+    const apiNamespaces = ctx.apiNamespaces ?? [];
     // Resource base resolution. Preferred: the simulator-supplied dev-server
     // origin, which statically serves the compiled `<appId>/<root>/…` tree (same
     // source the default dimina-fe `<webview>` reads). Fallback (no dev server —
@@ -550,6 +559,7 @@ async function handleSpawn(state, ctx, event, opts) {
             root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
+            apiNamespaces,
         });
     }
     const appSession = {
@@ -562,6 +572,7 @@ async function handleSpawn(state, ctx, event, opts) {
         serviceWc: serviceWindow.webContents,
         simulatorWc,
         serviceLoaded: false,
+        logicInjected: null,
         resourceBaseUrl,
         resourceServer,
         hostEnv,
@@ -583,6 +594,7 @@ async function handleSpawn(state, ctx, event, opts) {
         renderWc: null,
         renderLoaded: false,
         resourceLoadedSent: false,
+        renderLoadPending: false,
         windowConfig: rootWindowConfig,
     };
     state.appSessions.set(appSessionId, appSession);
@@ -653,7 +665,7 @@ async function handleSpawn(state, ctx, event, opts) {
             if (!serviceWindow.webContents.getURL().includes('service.html'))
                 return;
             serviceWindow.webContents.removeListener('did-finish-load', bootOnServiceLoad);
-            void bootServiceHost(state, appSession);
+            void bootServiceHost(state, appSession, ctx);
         };
         appSession.onServiceBoot = bootOnServiceLoad;
         serviceWindow.webContents.on('did-finish-load', bootOnServiceLoad);
@@ -665,13 +677,14 @@ async function handleSpawn(state, ctx, event, opts) {
             root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
+            apiNamespaces,
         }));
     }
     else {
         // Fresh window: its only navigation is service.html (issued inside
         // createServiceHostWindow), so the first did-finish-load is the spawn load.
         serviceWindow.webContents.once('did-finish-load', () => {
-            void bootServiceHost(state, appSession);
+            void bootServiceHost(state, appSession, ctx);
         });
     }
     return {
@@ -707,6 +720,7 @@ async function handlePageOpen(state, event, opts) {
         renderWc: null,
         renderLoaded: false,
         resourceLoadedSent: false,
+        renderLoadPending: false,
         windowConfig,
     };
     state.pageSessions.set(bridgeId, page);
@@ -761,26 +775,53 @@ function handleNavCallback(state, sender, payload) {
     sendCallback(ap, payload.callbacks.complete, result);
 }
 // ── Service-host boot & per-page resource handshake ──────────────────────────
-async function bootServiceHost(state, ap) {
+async function bootServiceHost(state, ap, ctx) {
     // Liveness guard: never boot a session that was already disposed. With pooling,
     // the service window is recycled, so a stale did-finish-load listener from an
     // early-disposed prior owner could otherwise fire here and inject the wrong
     // app's logic.js into the next spawn (the recycled webContents is shared).
     if (state.appSessions.get(ap.appSessionId) !== ap)
         return;
-    await injectLogicBundle(ap);
+    ap.logicInjected = await injectLogicBundle(ap);
+    if (!ap.logicInjected) {
+        // The compiled logic.js never executed, so `modDefine` registered nothing.
+        // Sending `loadResource` now would run `modRequire('app')` against an empty
+        // registry and throw the cryptic `module app not found` — masking the real
+        // cause (unreachable resource tree / failed compile / unresolved appId).
+        // Skip it and surface one actionable diagnostic instead; the render side
+        // gates on the same flag in `routeFromRender`.
+        reportLogicLoadFailure(ap, ctx);
+        return;
+    }
     // serviceLoaded is flipped only when service responds with
     // `serviceResourceLoaded`; see handleContainerMsg. Setting it here would
     // race a per-page `resourceLoaded` ahead of the service-side handler.
     forwardToService(ap, makeLoadResource(ap, ap.pages.get(ap.appSessionId), 'service'));
+    // Flush any render `loadResource` that arrived (renderHostReady) while
+    // injection was in-flight — now that the bundle is confirmed present.
+    for (const page of ap.pages.values()) {
+        if (page.renderLoadPending) {
+            page.renderLoadPending = false;
+            sendRenderLoadResource(ap, page);
+        }
+    }
+}
+function sendRenderLoadResource(ap, page) {
+    if (page.renderWc && !page.renderWc.isDestroyed()) {
+        page.renderWc.send(C.TO_RENDER, { msg: makeLoadResource(ap, page, 'render') });
+    }
+}
+/** The compiled logic.js URL `injectLogicBundle` fetches (mode-dependent). */
+function logicBundleUrl(ap) {
+    return ap.resourceServer
+        ? new URL('logic.js', ap.resourceBaseUrl).toString()
+        : new URL(`${ap.appId}/${ap.root}/logic.js`, ap.resourceBaseUrl).toString();
 }
 async function injectLogicBundle(ap) {
     // Fetch the compiled service logic over HTTP from the same base the render
     // host reads (`<base><appId>/<root>/logic.js`). The fallback local server
     // serves its root, so `<base>logic.js` resolves there too — both are http.
-    const logicUrl = ap.resourceServer
-        ? new URL('logic.js', ap.resourceBaseUrl).toString()
-        : new URL(`${ap.appId}/${ap.root}/logic.js`, ap.resourceBaseUrl).toString();
+    const logicUrl = logicBundleUrl(ap);
     try {
         const res = await fetch(logicUrl);
         if (!res.ok)
@@ -790,11 +831,31 @@ async function injectLogicBundle(ap) {
         // relative map would 404 and break sourcemapped console frames / Sources.
         const logicContent = rewriteSourceMappingUrl(await res.text(), logicUrl);
         await ap.serviceWc.executeJavaScript(`${logicContent}\n//# sourceURL=${logicUrl}`, true);
+        return true;
     }
     catch (error) {
         console.warn('[bridge-router] unable to inject service logic.js:', error);
+        return false;
     }
 }
+/**
+ * Emit one actionable diagnostic when the compiled logic bundle could not be
+ * loaded — the single point where "the app's compiled resource tree is
+ * unreachable" is known with certainty. Goes to the main-process log AND the
+ * guest console sink so it surfaces in the devtools Console panel where the
+ * developer would otherwise see only the misleading `module app not found`.
+ */
+function reportLogicLoadFailure(ap, ctx) {
+    const hint = ap.appId === 'unknown'
+        ? ' appId could not be resolved (it fell back to "unknown") — the mini-program likely failed to compile or its project manifest/app config is missing.'
+        : '';
+    const message = `[dimina-kit] Failed to load the mini-program logic bundle from ${logicBundleUrl(ap)}. `
+        + 'The service runtime has no registered modules, so no page can mount.'
+        + hint
+        + ` Verify the project compiled successfully and that the resource server serves "${ap.appId}/${ap.root}/".`;
+    console.error(message);
+    ctx.guestConsole?.emit({ source: 'service', level: 'error', args: [message] });
+}
 function maybeSendResourceLoaded(ap, page) {
     if (page.resourceLoadedSent || !ap.serviceLoaded || !page.renderLoaded)
         return;
@@ -842,9 +903,21 @@ function routeFromService(state, ap, defaultPage, msg, ctx) {
 }
 function routeFromRender(state, ap, page, msg, ctx) {
     if (msg.type === 'renderHostReady') {
-        if (page.renderWc && !page.renderWc.isDestroyed()) {
-            page.renderWc.send(C.TO_RENDER, { msg: makeLoadResource(ap, page, 'render') });
+        // Logic injection definitively failed: the render bundle shares the same
+        // (unreachable) resource tree, so `loadResource` here would only produce a
+        // second cryptic `module <pagePath> not found`. bootServiceHost already
+        // surfaced the actionable diagnostic — stay silent.
+        if (ap.logicInjected === false)
+            return;
+        // Injection still in-flight: the render guest fires `renderHostReady` on its
+        // own DOMContentLoaded, which routinely beats the async fetch+inject. Hold
+        // the render `loadResource` and let `bootServiceHost` flush it once the
+        // bundle settles, so a failed bundle never reaches the render side.
+        if (ap.logicInjected === null) {
+            page.renderLoadPending = true;
+            return;
         }
+        sendRenderLoadResource(ap, page);
         return;
     }
     if (msg.type === 'renderResourceLoaded') {
@@ -882,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 —
@@ -922,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);
@@ -974,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
@@ -1266,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/main/windows/service-host-window/create.d.ts

@@ -21,6 +21,13 @@ export interface ServiceHostWindowOptions {
     root?: string;
     resourceBaseUrl: string;
     hostEnvSnapshot?: Record<string, unknown>;
+    /**
+     * Custom API namespace names (host config `apiNamespaces`, e.g. `['qd']`).
+     * Encoded into the spawn URL so the service-host preload can install them as
+     * `globalThis.__diminaApiNamespaces` before service.js evaluates — without
+     * which page logic referencing `qd.*` throws `ReferenceError: qd is not defined`.
+     */
+    apiNamespaces?: string[];
 }
 /**
  * Construct an (un-navigated) service-host BrowserWindow. Split out from

package/dist/main/windows/service-host-window/create.js

@@ -60,6 +60,11 @@ export function buildServiceHostSpawnUrl(opts) {
         // Without this, sync-impls/system-info.ts falls back to generic defaults.
         url.searchParams.set('hostEnv', encodeURIComponent(JSON.stringify(opts.hostEnvSnapshot)));
     }
+    if (opts.apiNamespaces && opts.apiNamespaces.length > 0) {
+        // CSV of namespace names; the preload reads this back into
+        // `globalThis.__diminaApiNamespaces`. URLSearchParams round-trips the comma.
+        url.searchParams.set('apiNamespaces', opts.apiNamespaces.join(','));
+    }
     return url.toString();
 }
 /**

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,