@heybox/hb-sdk 0.7.4-alpha.5 → 0.7.4

package/dist/devtools/browser-dev-host/main.js

@@ -2795,7 +2795,7 @@ function inferBodyEncoding(headers, data, official) {
         return 'json';
     if (typeof URLSearchParams !== 'undefined' && data instanceof URLSearchParams)
         return 'form';
-    if (official && (Array.isArray(data) || isPlainRecord(data)))
+    if (official && (Array.isArray(data) || isPlainRecord$1(data)))
         return 'form';
     return isPlainJsonValue(data) ? 'json' : undefined;
 }
@@ -2811,7 +2811,7 @@ function isPlainJsonValue(value) {
         typeof value === 'number' ||
         (typeof value === 'object' && !ArrayBuffer.isView(value) && !(value instanceof ArrayBuffer)));
 }
-function isPlainRecord(value) {
+function isPlainRecord$1(value) {
     if (typeof value !== 'object' || value === null)
         return false;
     const prototype = Object.getPrototypeOf(value);
@@ -10051,10 +10051,26 @@ function isPlainObject(value) {
 }
 
 /** Dev Shell 读取局域网 Dev Session endpoint 的 query 参数。 */
-const MINI_PROGRAM_DEV_CONTEXT_QUERY_PARAM = 'dev_context_url';
 /** Browser Dev Host 创建和读取 Dev Session 的固定路径。 */
 const MINI_PROGRAM_DEV_CONTEXT_PATH = '/__hb_sdk__/dev-context';
 
+function parseBrowserDevPermissionState(value) {
+    if (!isPlainRecord(value) || !hasExactKeys(value, ['networkRequest']))
+        return undefined;
+    const networkRequest = value.networkRequest;
+    if (!isPlainRecord(networkRequest) || !hasExactKeys(networkRequest, ['status', 'useOfficialDomain']))
+        return undefined;
+    if (networkRequest.status !== 'enabled' && networkRequest.status !== 'disabled')
+        return undefined;
+    if (typeof networkRequest.useOfficialDomain !== 'boolean')
+        return undefined;
+    return {
+        networkRequest: {
+            status: networkRequest.status,
+            useOfficialDomain: networkRequest.useOfficialDomain,
+        },
+    };
+}
 const DEFAULT_PERMISSION_STATE = {
     networkRequest: {
         status: 'disabled',
@@ -10087,68 +10103,243 @@ function createBrowserDevRuntimePermissions(state) {
         ],
     };
 }
-function createMiniProgramDevReleaseDiagnostics(context, localState) {
-    if (context.source === 'anonymous') {
-        return [
-            {
-                code: 'REMOTE_CONTEXT_UNAVAILABLE',
-                severity: 'warning',
-                message: `未获取到线上权限配置，本地模拟不代表上线状态${context.warning ? `：${context.warning}` : ''}`,
-            },
-        ];
-    }
-    const parsedRemote = parseMiniProgramRuntimePermissions(context.runtimePermissions);
-    if (!parsedRemote.valid) {
-        return [
-            {
-                code: 'REMOTE_PERMISSIONS_INVALID',
-                severity: 'warning',
-                message: '线上权限配置不可用，本地模拟不代表上线状态。',
-            },
-        ];
+/** Mobile Dev Session 不允许官方域名；创建时只冻结 network.request 开关。 */
+function createMobileDevSessionRuntimePermissions(state) {
+    return createBrowserDevRuntimePermissions({
+        networkRequest: {
+            status: state.networkRequest.status,
+            useOfficialDomain: false,
+        },
+    });
+}
+function cloneDefaultPermissionState() {
+    return {
+        networkRequest: { ...DEFAULT_PERMISSION_STATE.networkRequest },
+    };
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function hasExactKeys(value, keys) {
+    const actualKeys = Object.keys(value);
+    return actualKeys.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+
+function createBrowserDevHostStatusDrain(options) {
+    let activeFetch;
+    let dirty = false;
+    let disposed = false;
+    let drainTask;
+    return {
+        invalidate(hint) {
+            if (disposed)
+                return Promise.resolve({ ok: false });
+            if (options.shouldSkip?.(hint, { draining: drainTask !== undefined })) {
+                return drainTask ?? Promise.resolve({ ok: true });
+            }
+            dirty = true;
+            drainTask ?? (drainTask = drain().finally(() => {
+                drainTask = undefined;
+            }));
+            return drainTask;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            dirty = false;
+            activeFetch?.abort();
+            activeFetch = undefined;
+        },
+    };
+    async function drain() {
+        let outcome = { ok: true };
+        while (dirty && !disposed) {
+            dirty = false;
+            const fetchController = new AbortController();
+            activeFetch = fetchController;
+            let canonical;
+            try {
+                canonical = await options.fetch(fetchController.signal);
+            }
+            catch (error) {
+                outcome = { ok: false };
+                if (!disposed && !fetchController.signal.aborted)
+                    reportError(error);
+                continue;
+            }
+            finally {
+                if (activeFetch === fetchController)
+                    activeFetch = undefined;
+            }
+            if (disposed)
+                return { ok: false };
+            let applied;
+            try {
+                applied = options.apply(canonical);
+            }
+            catch (error) {
+                outcome = { ok: false };
+                if (!disposed)
+                    reportError(error);
+                continue;
+            }
+            if (disposed)
+                return { ok: false };
+            outcome = { ok: true };
+            if (!options.hasChanged(applied))
+                continue;
+            try {
+                await options.onChanged(applied);
+            }
+            catch (error) {
+                outcome = { ok: false };
+                if (!disposed)
+                    reportError(error);
+            }
+        }
+        return disposed ? { ok: false } : outcome;
     }
-    const remoteNetworkRequest = parsedRemote.permissions['network.request'];
-    const remoteState = remoteNetworkRequest
-        ? {
-            status: remoteNetworkRequest.status,
-            useOfficialDomain: remoteNetworkRequest.config.useOfficialDomain === true,
+    function reportError(error) {
+        try {
+            options.onError(error);
+        }
+        catch {
+            // 错误观察方不能中断状态同步或产生未处理 rejection。
         }
-        : DEFAULT_PERMISSION_STATE.networkRequest;
-    if (localState.networkRequest.status === 'enabled' && remoteState.status !== 'enabled') {
-        return [
-            {
-                code: 'NETWORK_REQUEST_DISABLED_ONLINE',
-                severity: 'warning',
-                message: '当前本地允许 network.request，但线上权限已关闭；上线后请求会返回 PERMISSION_DENIED。',
-            },
-        ];
     }
-    if (localState.networkRequest.status === 'enabled' && localState.networkRequest.useOfficialDomain && !remoteState.useOfficialDomain) {
-        return [
-            {
-                code: 'OFFICIAL_DOMAIN_DISABLED_ONLINE',
-                severity: 'warning',
-                message: '当前本地允许访问小黑盒官方域名，但线上权限未开放；上线后相关请求会返回 PERMISSION_DENIED。',
-            },
-        ];
+}
+
+function createBrowserDevHostAccountStatusDrain(options) {
+    return createBrowserDevHostStatusDrain({
+        apply: options.applyStatus,
+        fetch: options.fetchStatus,
+        hasChanged: (applied) => applied.changed,
+        onChanged: (applied) => options.reconcile(applied.status),
+        onError: options.onError,
+        shouldSkip: (revisionHint) => revisionHint !== undefined && revisionHint <= options.getCanonicalRevision(),
+    });
+}
+
+function createBrowserDevHostAccountStatusPoll(options) {
+    const minDelayMs = options.minDelayMs ?? 1000;
+    const maxDelayMs = options.maxDelayMs ?? 15000;
+    let delayMs = minDelayMs;
+    let disposed = false;
+    let timer;
+    return {
+        schedule,
+        reset() {
+            delayMs = minDelayMs;
+            clearTimer();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            clearTimer();
+        },
+    };
+    function schedule() {
+        if (disposed || options.isDisposed())
+            return;
+        clearTimer();
+        timer = options.timers.setTimeout(async () => {
+            timer = undefined;
+            let outcome;
+            try {
+                outcome = await options.invalidate();
+            }
+            catch {
+                outcome = { ok: false };
+            }
+            if (disposed || options.isDisposed())
+                return;
+            if (outcome.ok) {
+                delayMs = minDelayMs;
+                options.connectEvents();
+                return;
+            }
+            delayMs = Math.min(delayMs * 2, maxDelayMs);
+            schedule();
+        }, delayMs);
+    }
+    function clearTimer() {
+        if (timer !== undefined)
+            options.timers.clearTimeout(timer);
+        timer = undefined;
     }
-    return [];
 }
-function cloneDefaultPermissionState() {
+
+function createBrowserDevHostPermissionStatusDrain(options) {
+    const drain = createBrowserDevHostStatusDrain({
+        apply: options.applyCanonical,
+        fetch: options.fetchCanonical,
+        hasChanged: Boolean,
+        onChanged: options.onChanged,
+        onError: options.onError,
+        shouldSkip: (input, { draining }) => !draining && !input?.force && input?.hint !== undefined && options.equals(input.hint, options.getCurrent()),
+    });
     return {
-        networkRequest: { ...DEFAULT_PERMISSION_STATE.networkRequest },
+        dispose: drain.dispose,
+        invalidate(hint, invalidateOptions) {
+            return drain.invalidate({ force: invalidateOptions?.force, hint });
+        },
     };
 }
 
-const LOGIN_UNAVAILABLE_MESSAGE = '外部 PKCE 登录服务尚未配置';
-function applyBrowserDevLoginAvailability(options) {
-    options.loginButton.disabled = !options.available;
-    options.loginButton.title = options.available ? '' : LOGIN_UNAVAILABLE_MESSAGE;
-    options.userStatus.textContent = options.available
-        ? options.userId
-            ? `已登录 · ${options.userId}`
-            : '未登录'
-        : `登录不可用：${LOGIN_UNAVAILABLE_MESSAGE}`;
+const SCOPE_LABELS = {
+    identity: '小程序身份',
+    profile: '昵称和头像',
+};
+function confirmBrowserDevHostAuthorization(input) {
+    return new Promise((resolve, reject) => {
+        if (input.signal.aborted) {
+            reject(input.signal.reason);
+            return;
+        }
+        const root = document.createElement('div');
+        root.className = 'hb-sdk-auth-dialog';
+        root.setAttribute('role', 'dialog');
+        root.setAttribute('aria-modal', 'true');
+        root.innerHTML = `
+      <div class="hb-sdk-auth-dialog__panel">
+        <h2>授权请求</h2>
+        <p class="hb-sdk-auth-dialog__app">${escapeHtml$2(input.miniProgram?.name || '当前小程序')} 申请访问：</p>
+        <ul class="hb-sdk-auth-dialog__scopes">${input.scopes.map((scope) => `<li>${escapeHtml$2(SCOPE_LABELS[scope] || scope)}</li>`).join('')}</ul>
+        ${input.userProfile?.nickname
+            ? `<p class="hb-sdk-auth-dialog__profile">当前账号：${escapeHtml$2(input.userProfile.nickname)}</p>`
+            : ''}
+        <div class="hb-sdk-auth-dialog__actions">
+          <button type="button" data-action="deny">拒绝</button>
+          <button type="button" class="primary" data-action="allow">允许</button>
+        </div>
+      </div>
+    `;
+        const finish = (decision) => {
+            cleanup();
+            resolve(decision);
+        };
+        const onAbort = () => {
+            cleanup();
+            reject(input.signal.reason);
+        };
+        const cleanup = () => {
+            input.signal.removeEventListener('abort', onAbort);
+            root.remove();
+        };
+        root.querySelector('[data-action="allow"]')?.addEventListener('click', () => {
+            finish({ status: 'granted', grantedScopes: [...input.scopes] });
+        });
+        root.querySelector('[data-action="deny"]')?.addEventListener('click', () => {
+            finish({ status: 'cancelled' });
+        });
+        input.signal.addEventListener('abort', onAbort, { once: true });
+        document.body.appendChild(root);
+    });
+}
+function escapeHtml$2(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#039;');
 }
 
 function createBrowserDevHostLaunchConfiguration(input) {
@@ -10165,58 +10356,963 @@ function createBrowserDevHostLaunchConfiguration(input) {
     };
 }
 
+const ACTION_DIALOG_STYLE_ID = 'hb-sdk-action-dialog-style';
+function promptBrowserDevHostAction(input) {
+    return new Promise((resolve, reject) => {
+        if (input.signal?.aborted) {
+            reject(input.signal.reason);
+            return;
+        }
+        ensureActionDialogStyles();
+        const root = document.createElement('div');
+        root.className = 'hb-sdk-action-dialog';
+        root.setAttribute('role', 'dialog');
+        root.setAttribute('aria-modal', 'true');
+        root.innerHTML = `
+      <div class="hb-sdk-action-dialog__panel">
+        <h2>${escapeHtml$1(input.title)}</h2>
+        <pre class="hb-sdk-action-dialog__detail">${escapeHtml$1(input.detail)}</pre>
+        <div class="hb-sdk-action-dialog__actions">
+          <button type="button" class="primary" data-action="confirm">确定</button>
+        </div>
+      </div>
+    `;
+        const finish = () => {
+            cleanup();
+            resolve();
+        };
+        const onAbort = () => {
+            cleanup();
+            reject(input.signal?.reason);
+        };
+        const cleanup = () => {
+            input.signal?.removeEventListener('abort', onAbort);
+            root.remove();
+        };
+        root.querySelector('[data-action="confirm"]')?.addEventListener('click', finish);
+        input.signal?.addEventListener('abort', onAbort, { once: true });
+        document.body.appendChild(root);
+    });
+}
+async function promptOpenAppPage(protocol, context) {
+    await promptBrowserDevHostAction({
+        title: '打开页面',
+        detail: ['protocolType: ' + protocol.protocolType, 'path: ' + protocol.path, 'params: ' + stringifyJson(protocol.params)].join('\n'),
+        signal: context.signal,
+    });
+}
+async function promptShowShareMenu(options, context) {
+    await promptBrowserDevHostAction({
+        title: '分享',
+        detail: [
+            'title: ' + options.title,
+            'description: ' + options.description,
+            'url: ' + options.url,
+            'channel: ' + stringifyJson(options.channel),
+            'post: ' + stringifyJson(options.post),
+        ].join('\n'),
+        signal: context.signal,
+    });
+    return undefined;
+}
+async function promptCaptureAndShare(options, context) {
+    // 调试页只提示截图参数，不读取 canvas。
+    await promptBrowserDevHostAction({
+        title: '截图分享',
+        detail: ['rect: ' + stringifyJson(options.rect), 'post: ' + stringifyJson(options.post)].join('\n'),
+        signal: context.signal,
+    });
+    return undefined;
+}
+function stringifyJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+function escapeHtml$1(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#039;');
+}
+/** 样式跟 index.html 解耦，避免和其他 agent 同时改静态页冲突。 */
+function ensureActionDialogStyles() {
+    if (document.getElementById(ACTION_DIALOG_STYLE_ID)) {
+        return;
+    }
+    const style = document.createElement('style');
+    style.id = ACTION_DIALOG_STYLE_ID;
+    style.textContent = `
+    .hb-sdk-action-dialog {
+      position: fixed;
+      inset: 0;
+      z-index: 40;
+      display: grid;
+      place-items: center;
+      padding: 24px;
+      background: rgba(15, 23, 42, 0.45);
+    }
+
+    .hb-sdk-action-dialog__panel {
+      width: min(420px, 100%);
+      border-radius: 12px;
+      padding: 20px;
+      background: #fff;
+      box-shadow: 0 20px 45px rgba(15, 23, 42, 0.2);
+    }
+
+    .hb-sdk-action-dialog__panel h2 {
+      margin: 0 0 8px;
+      font-size: 18px;
+    }
+
+    .hb-sdk-action-dialog__detail {
+      margin: 0 0 16px;
+      max-height: 40vh;
+      overflow: auto;
+      color: #1f2933;
+      font-family: inherit;
+      font-size: 12px;
+      line-height: 1.6;
+      white-space: pre-wrap;
+      overflow-wrap: anywhere;
+      word-break: break-word;
+    }
+
+    .hb-sdk-action-dialog__actions {
+      display: flex;
+      justify-content: flex-end;
+      gap: 8px;
+    }
+
+    .hb-sdk-action-dialog__actions button {
+      min-height: 36px;
+      border: 1px solid #cad5e2;
+      border-radius: 6px;
+      padding: 0 12px;
+      background: #fff;
+      cursor: pointer;
+    }
+
+    .hb-sdk-action-dialog__actions .primary {
+      border-color: #2563eb;
+      color: #fff;
+      background: #2563eb;
+    }
+  `;
+    document.head.appendChild(style);
+}
+
+const STYLE_ID = 'hb-sdk-feedback-style';
+const TOAST_DURATION_MS = 2000;
+const VIBRATE_DURATION_MS = {
+    light: 20,
+    medium: 40,
+    heavy: 80,
+};
+const VIBRATE_FLASH_MS = 120;
+const FEEDBACK_STYLE = `
+.hb-sdk-feedback-toast-stack {
+  position: fixed;
+  top: 16px;
+  left: 50%;
+  z-index: 50;
+  display: grid;
+  gap: 8px;
+  transform: translateX(-50%);
+  pointer-events: none;
+}
+.hb-sdk-feedback-toast {
+  min-width: 160px;
+  max-width: min(420px, calc(100vw - 32px));
+  border-radius: 8px;
+  padding: 10px 14px;
+  color: #fff;
+  background: #334155;
+  box-shadow: 0 10px 24px rgba(15, 23, 42, 0.18);
+  text-align: center;
+  line-height: 1.5;
+}
+.hb-sdk-feedback-toast--success {
+  background: #047857;
+}
+.hb-sdk-feedback-toast--error {
+  background: #b91c1c;
+}
+.hb-sdk-feedback-loading {
+  position: fixed;
+  inset: 0;
+  z-index: 50;
+  display: grid;
+  place-items: center;
+  padding: 24px;
+  background: rgba(15, 23, 42, 0.45);
+}
+.hb-sdk-feedback-loading__panel {
+  border-radius: 12px;
+  padding: 20px 28px;
+  color: #1f2933;
+  background: #fff;
+  box-shadow: 0 20px 45px rgba(15, 23, 42, 0.2);
+  font-size: 16px;
+}
+html.hb-sdk-feedback-vibrate-flash {
+  filter: brightness(1.18);
+}
+`;
+/** 全局只保留一个 loading 遮罩。 */
+let loadingRoot;
+let toastStack;
+function showBrowserDevHostToast(options) {
+    ensureStyles();
+    const stack = getToastStack();
+    const toast = document.createElement('div');
+    toast.className = 'hb-sdk-feedback-toast';
+    if (options.status === 'success' || options.status === 'error') {
+        toast.classList.add(`hb-sdk-feedback-toast--${options.status}`);
+    }
+    toast.setAttribute('role', 'status');
+    // textContent 避免 toast 文案 XSS
+    toast.textContent = options.message;
+    stack.appendChild(toast);
+    window.setTimeout(() => {
+        toast.remove();
+        if (toastStack && toastStack.childElementCount === 0) {
+            toastStack.remove();
+            toastStack = undefined;
+        }
+    }, TOAST_DURATION_MS);
+    return Promise.resolve();
+}
+function showBrowserDevHostLoading(options) {
+    ensureStyles();
+    const dismissible = options?.dismissible === true;
+    if (!loadingRoot) {
+        const root = document.createElement('div');
+        root.className = 'hb-sdk-feedback-loading';
+        root.setAttribute('role', 'status');
+        root.setAttribute('aria-live', 'polite');
+        root.innerHTML = `<div class="hb-sdk-feedback-loading__panel">加载中</div>`;
+        root.addEventListener('click', (event) => {
+            if (event.target !== root)
+                return;
+            if (root.dataset.dismissible !== 'true')
+                return;
+            void hideBrowserDevHostLoading();
+        });
+        document.body.appendChild(root);
+        loadingRoot = root;
+    }
+    loadingRoot.dataset.dismissible = dismissible ? 'true' : 'false';
+    return Promise.resolve();
+}
+function hideBrowserDevHostLoading() {
+    loadingRoot?.remove();
+    loadingRoot = undefined;
+    return Promise.resolve();
+}
+async function vibrateBrowserDevHost(options) {
+    ensureStyles();
+    await wait(Math.max(0, options.delay));
+    flashVibrate();
+    const vibrate = navigator.vibrate;
+    if (typeof vibrate !== 'function') {
+        return;
+    }
+    try {
+        // DOM lib 将 VibratePattern 收成 Iterable<number>，单次时长仍按 number 传入。
+        vibrate.call(navigator, VIBRATE_DURATION_MS[options.intensity]);
+    }
+    catch {
+        // 调试页无震动能力时保持静默
+    }
+}
+function setBrowserDevHostScreenshotChromeHidden(hidden) {
+    document.documentElement.dataset.screenshotChromeHidden = hidden ? 'true' : 'false';
+}
+function ensureStyles() {
+    // 调试页 CSS 只注入一次
+    if (document.getElementById(STYLE_ID))
+        return;
+    const style = document.createElement('style');
+    style.id = STYLE_ID;
+    style.textContent = FEEDBACK_STYLE;
+    document.head.appendChild(style);
+}
+function getToastStack() {
+    if (toastStack?.isConnected) {
+        return toastStack;
+    }
+    const stack = document.createElement('div');
+    stack.className = 'hb-sdk-feedback-toast-stack';
+    document.body.appendChild(stack);
+    toastStack = stack;
+    return stack;
+}
+function flashVibrate() {
+    const root = document.documentElement;
+    root.classList.add('hb-sdk-feedback-vibrate-flash');
+    window.setTimeout(() => {
+        root.classList.remove('hb-sdk-feedback-vibrate-flash');
+    }, VIBRATE_FLASH_MS);
+}
+function wait(ms) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        window.setTimeout(resolve, ms);
+    });
+}
+
+function createBrowserDevHostPresentation(input) {
+    return {
+        close: async () => {
+            await input.close();
+        },
+        reload: async () => {
+            location.reload();
+        },
+        getViewportMetrics: () => ({
+            windowWidth: window.innerWidth,
+            windowHeight: window.innerHeight,
+            screenWidth: window.screen.width,
+            screenHeight: window.screen.height,
+            pixelRatio: window.devicePixelRatio,
+        }),
+        getNavigationBarHeight: () => 0,
+        setNavigationBarStyle: (style) => {
+            document.documentElement.dataset.navigationBarStyle = style;
+        },
+        setClipboard: async ({ text }) => {
+            await navigator.clipboard.writeText(text);
+        },
+        showToast: async ({ message, status }) => {
+            input.pushLog('host.message', { message, status });
+            await showBrowserDevHostToast({ message, status });
+        },
+        showLoading: showBrowserDevHostLoading,
+        hideLoading: hideBrowserDevHostLoading,
+        vibrate: vibrateBrowserDevHost,
+        openAppPage: promptOpenAppPage,
+        showShareMenu: promptShowShareMenu,
+        captureAndShare: promptCaptureAndShare,
+        setScreenshotChromeHidden: setBrowserDevHostScreenshotChromeHidden,
+    };
+}
+
+const OPEN_IN_APP_URL = 'https://api.xiaoheihe.cn/open_inapp/';
+function createMobileLaunchRedirectHttpUrl(options) {
+    const port = typeof options.port === 'number' ? options.port : Number(options.port);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new TypeError('Mobile launch redirect port is invalid');
+    }
+    if (!/^[A-Za-z0-9_-]{22}$/.test(options.token)) {
+        throw new TypeError('Mobile launch redirect token is invalid');
+    }
+    const url = new URL(`http://${options.host}:${port}/l/${options.token}`);
+    if (url.protocol !== 'http:' ||
+        url.hostname !== options.host ||
+        url.port !== String(port) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new TypeError('Mobile launch redirect host is invalid');
+    }
+    return url.href;
+}
+function createMobileAppRedirectQrPayload(redirectUrl) {
+    const url = new URL(redirectUrl);
+    if (url.protocol !== 'http:' || url.username || url.password) {
+        throw new TypeError('Mobile launch redirect URL must be an HTTP URL without credentials');
+    }
+    return `${OPEN_IN_APP_URL}#${createHeyboxProtocol({
+        protocol_type: 'openWindow',
+        full_screen: true,
+        navigation_bar: {
+            title: '',
+        },
+        webview: {
+            url: url.href,
+            pull: false,
+            refresh: false,
+        },
+    })}`;
+}
+function createHeyboxProtocol(payload) {
+    return `heybox://${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+const BROWSER_DEV_HOST_CHANNEL_VERSION = 1;
+const BROWSER_DEV_HOST_CHANNEL_MAX_TEXT_BYTES = 64 * 1024;
+const BROWSER_DEV_HOST_CHANNEL_MAX_JSON_DEPTH = 64;
+const FIXED_BASE64URL_PATTERN = /^[A-Za-z0-9_-]{22}$/;
+class BrowserDevHostChannelError extends TypeError {
+    constructor(code, message) {
+        super(message);
+        this.name = 'BrowserDevHostChannelError';
+        this.code = code;
+    }
+}
+function parseBrowserDevHostServerMessage(raw, binary = false) {
+    const value = parseTextFrame(raw, binary);
+    assertRecord(value, 'Server message');
+    assertVersion(value);
+    switch (value.type) {
+        case 'grant':
+            assertExactKeys(value, ['version', 'type', 'connectionEpoch', 'nextClientSequence', 'nextServerSequence', 'snapshot'], 'grant');
+            assertFixedBase64Url(value.connectionEpoch, 'connectionEpoch');
+            assertNonNegativeSafeInteger(value.nextClientSequence, 'nextClientSequence');
+            assertNonNegativeSafeInteger(value.nextServerSequence, 'nextServerSequence');
+            assertSnapshot(value.snapshot);
+            return value;
+        case 'event':
+            assertExactKeys(value, ['version', 'type', 'connectionEpoch', 'sequence', 'event', 'snapshot'], 'event');
+            assertFixedBase64Url(value.connectionEpoch, 'connectionEpoch');
+            assertNonNegativeSafeInteger(value.sequence, 'sequence');
+            if (value.event !== 'account.changed' && value.event !== 'status.changed') {
+                invalidMessage('event must be account.changed or status.changed');
+            }
+            assertSnapshot(value.snapshot);
+            return value;
+        case 'heartbeat':
+            assertExactKeys(value, ['version', 'type', 'connectionEpoch', 'sequence'], 'heartbeat');
+            assertFixedBase64Url(value.connectionEpoch, 'connectionEpoch');
+            assertNonNegativeSafeInteger(value.sequence, 'sequence');
+            return value;
+        default:
+            return invalidMessage('Unknown server message type');
+    }
+}
+function createBrowserDevHostChannelSequenceGuard(input) {
+    const connectionEpoch = input.connectionEpoch;
+    assertFixedBase64Url(connectionEpoch, 'connectionEpoch');
+    assertNonNegativeSafeInteger(input.nextSequence, 'nextSequence');
+    let nextSequence = input.nextSequence;
+    return {
+        get nextSequence() {
+            return nextSequence;
+        },
+        accept(message) {
+            assertFixedBase64Url(message.connectionEpoch, 'connectionEpoch');
+            assertNonNegativeSafeInteger(message.sequence, 'sequence');
+            if (message.connectionEpoch !== connectionEpoch) {
+                throw new BrowserDevHostChannelError('INVALID_SEQUENCE', 'Connection epoch does not match');
+            }
+            if (nextSequence === undefined) {
+                throw new BrowserDevHostChannelError('INVALID_SEQUENCE', 'Sequence is exhausted');
+            }
+            if (message.sequence !== nextSequence) {
+                throw new BrowserDevHostChannelError('INVALID_SEQUENCE', `Expected sequence ${nextSequence}`);
+            }
+            nextSequence = nextSequence === Number.MAX_SAFE_INTEGER ? undefined : nextSequence + 1;
+        },
+    };
+}
+function parseTextFrame(raw, binary) {
+    if (binary) {
+        throw new BrowserDevHostChannelError('BINARY_FRAME', 'Binary frames are not supported');
+    }
+    if (typeof raw !== 'string') {
+        throw new BrowserDevHostChannelError('TEXT_FRAME_REQUIRED', 'Channel frame must be text');
+    }
+    if (raw.length > BROWSER_DEV_HOST_CHANNEL_MAX_TEXT_BYTES) {
+        throw new BrowserDevHostChannelError('TEXT_FRAME_TOO_LARGE', 'Channel text frame exceeds 64 KiB');
+    }
+    if (new TextEncoder().encode(raw).byteLength > BROWSER_DEV_HOST_CHANNEL_MAX_TEXT_BYTES) {
+        throw new BrowserDevHostChannelError('TEXT_FRAME_TOO_LARGE', 'Channel text frame exceeds 64 KiB');
+    }
+    try {
+        assertNoDuplicateJsonKeys(raw);
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error instanceof BrowserDevHostChannelError)
+            throw error;
+        throw new BrowserDevHostChannelError('INVALID_JSON', 'Channel frame must contain strict JSON');
+    }
+}
+function assertSnapshot(value) {
+    assertRecord(value, 'snapshot');
+    assertExactKeys(value, ['account', 'permissions'], 'snapshot');
+    assertRecord(value.account, 'snapshot.account');
+    assertExactKeys(value.account, ['revision'], 'snapshot.account');
+    assertNonNegativeSafeInteger(value.account.revision, 'snapshot.account.revision');
+    if (!parseBrowserDevPermissionState(value.permissions))
+        invalidMessage('snapshot.permissions is invalid');
+}
+function assertVersion(value) {
+    if (value.version !== BROWSER_DEV_HOST_CHANNEL_VERSION)
+        invalidMessage('version must be 1');
+}
+function assertRecord(value, field) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) {
+        invalidMessage(`${field} must be a plain JSON object`);
+    }
+}
+function assertExactKeys(value, required, field, optional = []) {
+    const keys = Object.keys(value);
+    if (required.some((key) => !Object.hasOwn(value, key)) || keys.some((key) => !required.includes(key) && !optional.includes(key))) {
+        invalidMessage(`${field} fields are invalid`);
+    }
+}
+function assertNonNegativeSafeInteger(value, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        invalidMessage(`${field} must be a non-negative safe integer`);
+    }
+}
+function assertFixedBase64Url(value, field) {
+    if (typeof value !== 'string' || !FIXED_BASE64URL_PATTERN.test(value)) {
+        invalidMessage(`${field} must be a 22-character base64url value`);
+    }
+}
+function invalidMessage(message) {
+    throw new BrowserDevHostChannelError('INVALID_MESSAGE', message);
+}
+function assertNoDuplicateJsonKeys(raw) {
+    const scanner = new StrictJsonKeyScanner(raw);
+    scanner.scan();
+}
+class StrictJsonKeyScanner {
+    constructor(source) {
+        this.source = source;
+        this.position = 0;
+    }
+    scan() {
+        this.skipWhitespace();
+        this.scanValue();
+        this.skipWhitespace();
+        if (this.position !== this.source.length)
+            throw new SyntaxError('Unexpected trailing JSON data');
+    }
+    scanValue(depth = 0) {
+        const character = this.source[this.position];
+        if (character === '{' || character === '[') {
+            if (depth >= BROWSER_DEV_HOST_CHANNEL_MAX_JSON_DEPTH) {
+                throw new BrowserDevHostChannelError('INVALID_JSON', 'Channel JSON exceeds maximum nesting depth');
+            }
+            return character === '{' ? this.scanObject(depth) : this.scanArray(depth);
+        }
+        if (character === '"') {
+            this.scanString();
+            return;
+        }
+        this.scanPrimitive();
+    }
+    scanObject(depth) {
+        this.position += 1;
+        this.skipWhitespace();
+        const keys = new Set();
+        if (this.consume('}'))
+            return;
+        while (true) {
+            if (this.source[this.position] !== '"')
+                throw new SyntaxError('JSON object key must be a string');
+            const keySource = this.scanString();
+            const key = JSON.parse(keySource);
+            if (typeof key !== 'string')
+                throw new SyntaxError('JSON object key must be a string');
+            if (keys.has(key)) {
+                throw new BrowserDevHostChannelError('INVALID_JSON', 'Channel JSON contains a duplicate key');
+            }
+            keys.add(key);
+            this.skipWhitespace();
+            if (!this.consume(':'))
+                throw new SyntaxError('Missing JSON object colon');
+            this.skipWhitespace();
+            this.scanValue(depth + 1);
+            this.skipWhitespace();
+            if (this.consume('}'))
+                return;
+            if (!this.consume(','))
+                throw new SyntaxError('Missing JSON object comma');
+            this.skipWhitespace();
+        }
+    }
+    scanArray(depth) {
+        this.position += 1;
+        this.skipWhitespace();
+        if (this.consume(']'))
+            return;
+        while (true) {
+            this.scanValue(depth + 1);
+            this.skipWhitespace();
+            if (this.consume(']'))
+                return;
+            if (!this.consume(','))
+                throw new SyntaxError('Missing JSON array comma');
+            this.skipWhitespace();
+        }
+    }
+    scanString() {
+        const start = this.position;
+        this.position += 1;
+        while (this.position < this.source.length) {
+            const character = this.source[this.position];
+            if (character === '"') {
+                this.position += 1;
+                return this.source.slice(start, this.position);
+            }
+            if (character === '\\') {
+                this.position += 2;
+            }
+            else {
+                this.position += 1;
+            }
+        }
+        throw new SyntaxError('Unterminated JSON string');
+    }
+    scanPrimitive() {
+        const start = this.position;
+        while (this.position < this.source.length && !/[\s,\]}]/.test(this.source[this.position] ?? '')) {
+            this.position += 1;
+        }
+        if (start === this.position)
+            throw new SyntaxError('Missing JSON value');
+    }
+    skipWhitespace() {
+        while (/[\t\n\r ]/.test(this.source[this.position] ?? ''))
+            this.position += 1;
+    }
+    consume(character) {
+        if (this.source[this.position] !== character)
+            return false;
+        this.position += 1;
+        return true;
+    }
+}
+
+const RECONNECT_DELAYS_MS = [1000, 2000, 4000, 8000, 15000];
+function createBrowserDevHostChannelClient(options) {
+    const updateListeners = new Set();
+    const createWebSocket = options.webSocketFactory ?? ((url) => new WebSocket(url));
+    const randomValues = options.randomValues ?? ((bytes) => crypto.getRandomValues(bytes));
+    const timers = options.timers ?? {
+        clearTimeout: (handle) => window.clearTimeout(handle),
+        setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+    };
+    const onlineTarget = options.onlineTarget ?? (typeof window === 'undefined' ? undefined : window);
+    const visibilityTarget = options.visibilityTarget ?? (typeof document === 'undefined' ? undefined : document);
+    const isOnline = options.isOnline ?? (() => typeof navigator === 'undefined' || navigator.onLine !== false);
+    let socket;
+    let detachSocketListeners;
+    let snapshot;
+    let disposed = false;
+    let reconnectAttempt = 0;
+    let reconnectTimer;
+    let started = false;
+    let lifecycleListenersAttached = false;
+    const diagnosticsSinceGrant = new Set();
+    const reportDiagnostic = (phase, code) => {
+        if (!options.onDiagnostic || diagnosticsSinceGrant.has(phase))
+            return;
+        diagnosticsSinceGrant.add(phase);
+        try {
+            options.onDiagnostic({ phase, ...(code ? { code } : {}) });
+        }
+        catch {
+            // 诊断观察方不能影响 Browser channel 或 HTTP/SSE fallback。
+        }
+    };
+    const publishSnapshot = (nextSnapshot, update, notifyEqual = false) => {
+        if (snapshot && nextSnapshot.account.revision < snapshot.account.revision)
+            return;
+        const equal = snapshot && JSON.stringify(nextSnapshot) === JSON.stringify(snapshot);
+        snapshot = nextSnapshot;
+        if (equal && !notifyEqual)
+            return;
+        for (const listener of updateListeners)
+            listener(nextSnapshot, update);
+    };
+    const scheduleReconnect = () => {
+        if (disposed || reconnectTimer !== undefined || socket)
+            return;
+        const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+        reconnectAttempt += 1;
+        reconnectTimer = timers.setTimeout(() => {
+            reconnectTimer = undefined;
+            connect();
+        }, delay);
+    };
+    const reconnectNow = () => {
+        if (disposed || !started || socket)
+            return;
+        if (reconnectTimer !== undefined) {
+            timers.clearTimeout(reconnectTimer);
+            reconnectTimer = undefined;
+        }
+        connect();
+    };
+    const onOnline = () => {
+        if (isOnline())
+            reconnectNow();
+    };
+    const onVisibilityChange = () => {
+        if (visibilityTarget && !visibilityTarget.hidden)
+            reconnectNow();
+    };
+    const attachLifecycleListeners = () => {
+        if (lifecycleListenersAttached)
+            return;
+        lifecycleListenersAttached = true;
+        onlineTarget?.addEventListener('online', onOnline);
+        visibilityTarget?.addEventListener('visibilitychange', onVisibilityChange);
+    };
+    const detachLifecycleListeners = () => {
+        if (!lifecycleListenersAttached)
+            return;
+        lifecycleListenersAttached = false;
+        onlineTarget?.removeEventListener('online', onOnline);
+        visibilityTarget?.removeEventListener('visibilitychange', onVisibilityChange);
+    };
+    const connect = () => {
+        if (disposed || socket)
+            return;
+        started = true;
+        attachLifecycleListeners();
+        if (reconnectTimer !== undefined) {
+            timers.clearTimeout(reconnectTimer);
+            reconnectTimer = undefined;
+        }
+        let nextSocket;
+        let clientNonce;
+        try {
+            nextSocket = createWebSocket(options.url);
+        }
+        catch {
+            reportDiagnostic('constructor', 'WEBSOCKET_CONSTRUCTION_FAILED');
+            scheduleReconnect();
+            return;
+        }
+        try {
+            clientNonce = createClientNonce(randomValues);
+        }
+        catch {
+            reportDiagnostic('entropy', 'NONCE_GENERATION_FAILED');
+            try {
+                nextSocket?.close(1011, 'channel initialization failed');
+            }
+            catch {
+                // WebSocket 可能尚未完成初始化。
+            }
+            scheduleReconnect();
+            return;
+        }
+        socket = nextSocket;
+        let connectionEpoch;
+        let nextClientSequence;
+        let serverSequenceGuard;
+        const detach = () => {
+            nextSocket.removeEventListener('open', onOpen);
+            nextSocket.removeEventListener('message', onMessage);
+            nextSocket.removeEventListener('close', onClose);
+            nextSocket.removeEventListener('error', onError);
+            if (detachSocketListeners === detach)
+                detachSocketListeners = undefined;
+        };
+        const fail = () => {
+            if (socket !== nextSocket)
+                return;
+            socket = undefined;
+            detach();
+            try {
+                nextSocket.close(1008, 'invalid channel state');
+            }
+            catch {
+                // WebSocket 已终止时只需进入 fallback 重连。
+            }
+            scheduleReconnect();
+        };
+        const onOpen = () => {
+            if (disposed || socket !== nextSocket)
+                return;
+            try {
+                nextSocket.send(JSON.stringify({
+                    version: BROWSER_DEV_HOST_CHANNEL_VERSION,
+                    type: 'hello',
+                    csrfToken: options.csrfToken,
+                    clientNonce,
+                }));
+            }
+            catch {
+                reportDiagnostic('send', 'HELLO_SEND_FAILED');
+                fail();
+            }
+        };
+        const onMessage = (event) => {
+            if (disposed || socket !== nextSocket)
+                return;
+            if (typeof event.data !== 'string') {
+                reportDiagnostic('parse', 'TEXT_FRAME_REQUIRED');
+                fail();
+                return;
+            }
+            let message;
+            try {
+                message = parseBrowserDevHostServerMessage(event.data);
+            }
+            catch (error) {
+                reportDiagnostic('parse', error instanceof BrowserDevHostChannelError ? error.code : 'INVALID_MESSAGE');
+                fail();
+                return;
+            }
+            if (message.type === 'grant') {
+                if (serverSequenceGuard) {
+                    reportDiagnostic('sequence', 'DUPLICATE_GRANT');
+                    fail();
+                    return;
+                }
+                connectionEpoch = message.connectionEpoch;
+                nextClientSequence = message.nextClientSequence;
+                serverSequenceGuard = createBrowserDevHostChannelSequenceGuard({
+                    connectionEpoch,
+                    nextSequence: message.nextServerSequence,
+                });
+                reconnectAttempt = 0;
+                diagnosticsSinceGrant.clear();
+                publishSnapshot(message.snapshot, { type: 'grant' });
+                return;
+            }
+            if (!serverSequenceGuard || !connectionEpoch || nextClientSequence === undefined) {
+                reportDiagnostic('sequence', 'MESSAGE_BEFORE_GRANT');
+                fail();
+                return;
+            }
+            try {
+                serverSequenceGuard.accept(message);
+            }
+            catch {
+                reportDiagnostic('sequence', 'INVALID_SEQUENCE');
+                fail();
+                return;
+            }
+            if (message.type === 'heartbeat') {
+                try {
+                    nextSocket.send(JSON.stringify({
+                        version: BROWSER_DEV_HOST_CHANNEL_VERSION,
+                        type: 'heartbeat.ack',
+                        connectionEpoch,
+                        sequence: nextClientSequence,
+                    }));
+                }
+                catch {
+                    reportDiagnostic('send', 'HEARTBEAT_ACK_SEND_FAILED');
+                    fail();
+                }
+                nextClientSequence = nextClientSequence === Number.MAX_SAFE_INTEGER ? undefined : nextClientSequence + 1;
+                return;
+            }
+            publishSnapshot(message.snapshot, { type: 'event', event: message.event }, true);
+        };
+        const onClose = () => {
+            if (socket !== nextSocket)
+                return;
+            reportDiagnostic('close', 'SOCKET_CLOSED');
+            socket = undefined;
+            detach();
+            scheduleReconnect();
+        };
+        const onError = () => {
+            reportDiagnostic('open', 'SOCKET_ERROR');
+            fail();
+        };
+        nextSocket.addEventListener('open', onOpen);
+        nextSocket.addEventListener('message', onMessage);
+        nextSocket.addEventListener('close', onClose);
+        nextSocket.addEventListener('error', onError);
+        detachSocketListeners = detach;
+    };
+    return {
+        connect,
+        subscribeUpdates(listener) {
+            updateListeners.add(listener);
+            return () => updateListeners.delete(listener);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            started = false;
+            detachLifecycleListeners();
+            if (reconnectTimer !== undefined)
+                timers.clearTimeout(reconnectTimer);
+            reconnectTimer = undefined;
+            const activeSocket = socket;
+            socket = undefined;
+            detachSocketListeners?.();
+            activeSocket?.close(1000, 'client disposed');
+            updateListeners.clear();
+        },
+    };
+}
+function encodeBase64Url(bytes) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+    let result = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index] ?? 0;
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        result += alphabet[first >> 2];
+        result += alphabet[((first & 0x03) << 4) | ((second ?? 0) >> 4)];
+        if (second !== undefined)
+            result += alphabet[((second & 0x0f) << 2) | ((third ?? 0) >> 6)];
+        if (third !== undefined)
+            result += alphabet[third & 0x3f];
+    }
+    return result;
+}
+function createClientNonce(randomValues) {
+    const bytes = randomValues(new Uint8Array(16));
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== 16)
+        throw new TypeError('Channel nonce source must fill 16 bytes');
+    const nonce = encodeBase64Url(bytes);
+    if (!/^[A-Za-z0-9_-]{22}$/.test(nonce))
+        throw new TypeError('Channel nonce source returned invalid bytes');
+    return nonce;
+}
+
 const BOOTSTRAP_PATH = '/__hb_sdk_bootstrap__';
 const DEV_PERMISSIONS_PATH = '/__hb_sdk__/dev-permissions';
+const MOBILE_LAUNCH_REDIRECT_PATH = '/__hb_sdk__/mobile-launch-redirect';
 const NETWORK_PATH = '/__hb_sdk__/network';
 const SESSION_STATUS_PATH = '/session/status';
-const SESSION_LOGIN_INTENT_PATH = '/session/login-intent';
-const SESSION_LOGOUT_PATH = '/session/logout';
 const SESSION_REQUEST_PATH = '/session/request';
 const SESSION_EVENTS_PATH = '/session/events';
 const MOBILE_QR_IMAGE_SIZE = 320;
 const NATIVE_LAUNCH_CONFIG_REFRESH_MS = 1000;
 const SESSION_POLL_MIN_MS = 1000;
 const SESSION_POLL_MAX_MS = 15000;
-const miniProgramUrl = new URL(location.href).searchParams.get('mini_url');
+const pageQuery = new URL(location.href).searchParams;
+const miniProgramUrl = pageQuery.get('mini_url');
+const uiPreview = pageQuery.get('ui_preview') === '1';
 const elements = {
-    bridgeStatus: queryElement('#bridge-status'),
-    copyDebugPageUrlButton: queryElement('#copy-debug-page-url-button'),
-    debugPageCopyStatus: queryElement('#debug-page-copy-status'),
-    debugPageUrl: queryElement('#debug-page-url'),
-    devContextStatus: queryElement('#dev-context-status'),
+    developerAvatar: queryElement('#developer-avatar'),
+    developerHint: queryElement('#developer-hint'),
+    developerName: queryElement('#developer-name'),
     device: queryElement('#device'),
     logs: queryElement('#logs'),
-    loginButton: queryElement('#login-button'),
-    macAppButton: queryElement('#mac-app-button'),
-    macAppStatus: queryElement('#mac-app-status'),
-    miniUrl: queryElement('#mini-url'),
+    miniProgramEmpty: queryElement('#mini-program-empty'),
+    miniProgramIcon: queryElement('#mini-program-icon'),
+    miniProgramId: queryElement('#mini-program-id'),
+    miniProgramName: queryElement('#mini-program-name'),
+    miniProgramSummary: queryElement('#mini-program-summary'),
     mobileLanSelect: queryElement('#mobile-lan-select'),
     mobileQrImage: queryElement('#mobile-qr-image'),
     mobileQrStatus: queryElement('#mobile-qr-status'),
-    networkPermissionSelect: queryElement('#network-permission-select'),
-    permissionPersistenceStatus: queryElement('#permission-persistence-status'),
-    releaseDiagnostics: queryElement('#release-diagnostics'),
-    resetPermissionsButton: queryElement('#reset-permissions-button'),
     storageSnapshot: queryElement('#storage-snapshot'),
-    userStatus: queryElement('#user-status'),
 };
-if (!miniProgramUrl) {
+if (!miniProgramUrl && !uiPreview) {
     elements.device.innerHTML = '<div class="error">Missing mini_url query.</div>';
     throw new Error('Missing mini_url query.');
 }
-const launchUrl = miniProgramUrl;
+const launchUrl = miniProgramUrl ?? 'about:blank';
 const bootstrap = await loadBootstrap();
 let lanAddresses = bootstrap.lanAddresses;
 let defaultLanAddressId = bootstrap.defaultLanAddressId;
-let macAppProtocol = bootstrap.macAppProtocol;
-let nativeAppLaunchUnavailableReason = bootstrap.nativeAppLaunchUnavailableReason;
+let mobileLaunchRedirect = bootstrap.mobileLaunchRedirect;
 let nativeLaunchConfigSignature = readNativeLaunchConfigSignature(bootstrap);
 let devContext = bootstrap.devContext;
 let remotePermissionState = createBrowserDevPermissionState(devContext);
 let permissionState = clonePermissionState(remotePermissionState);
-let hasPermissionOverride = false;
-let permissionActionMessage = '';
+let runtimePermissionState;
 let disposed = false;
+let hostGeneration = 0;
+const hostAbortController = new AbortController();
 let runtimeGeneration = 0;
 let activeRuntime;
 let activeTerminal;
@@ -10227,20 +11323,55 @@ let nativeLaunchConfigRefreshTimer;
 let nativeLaunchConfigRefreshInFlight = false;
 let mobileDevSessionCreation = Promise.resolve();
 let sessionRevision = -1;
+let sessionAuthenticated = false;
 let sessionUserId;
+let sessionUserNickname;
+let sessionUserAvatar;
 let sessionEventSource;
-let sessionPollTimer;
-let sessionPollDelay = SESSION_POLL_MIN_MS;
-let accountRevisionTask;
+let channelClient;
 const accountListeners = new Set();
+const accountStatusDrain = createBrowserDevHostAccountStatusDrain({
+    applyStatus: (status) => applySessionStatus(status, true),
+    fetchStatus: (signal) => fetchSessionStatus(combineAbortSignals(hostAbortController.signal, signal)),
+    getCanonicalRevision: () => sessionRevision,
+    onError: handleSessionNavigationError,
+    reconcile: () => reconcileAccountRevision(hostGeneration),
+});
+const accountStatusPoll = createBrowserDevHostAccountStatusPoll({
+    connectEvents: connectSessionEvents,
+    invalidate: () => accountStatusDrain.invalidate(),
+    isDisposed: () => disposed,
+    maxDelayMs: SESSION_POLL_MAX_MS,
+    minDelayMs: SESSION_POLL_MIN_MS,
+    timers: {
+        clearTimeout: (handle) => window.clearTimeout(handle),
+        setTimeout: (callback, delay) => window.setTimeout(() => void callback(), delay),
+    },
+});
+const permissionStatusDrain = createBrowserDevHostPermissionStatusDrain({
+    applyCanonical: (configuration) => {
+        applyPermissionConfiguration(configuration);
+        return !runtimePermissionState || !isSamePermissionState(permissionState, runtimePermissionState);
+    },
+    equals: isSamePermissionState,
+    fetchCanonical: (signal) => fetchPermissionConfiguration(combineAbortSignals(hostAbortController.signal, signal)),
+    getCurrent: () => permissionState,
+    onChanged: refreshRuntimeForCanonicalPermission,
+    onError: () => {
+        if (!disposed)
+            pushLog('permission.sync.failed', { code: 'CANONICAL_PERMISSION_FETCH_FAILED' });
+    },
+});
 await loadPersistedPermissionConfiguration();
 await refreshSessionStatus(false);
-updatePermissionControls();
-updateUserStatus();
+renderDeveloperAccount();
+renderMiniProgramSummary(resolveDisplayedMiniProgram(bootstrap));
 updateStorageSnapshot();
-elements.miniUrl.textContent = miniProgramUrl;
 await restartRuntime('initial');
-connectSessionEvents();
+if (!uiPreview) {
+    connectSessionEvents();
+    connectBrowserChannel();
+}
 setupControls();
 const mobileAppQrReady = setupMobileAppQr();
 if (bootstrap.devContext.source === 'remote') {
@@ -10252,25 +11383,17 @@ if (bootstrap.devContext.source === 'remote') {
 }
 function setupControls() {
     window.addEventListener('beforeunload', disposeBrowserDevHost);
-    elements.loginButton.addEventListener('click', () => {
-        void beginLogin().catch(handleSessionNavigationError);
-    });
-    queryElement('#logout-button').addEventListener('click', () => void logout());
-    queryElement('#show-button').addEventListener('click', () => activeRuntime?.show());
-    queryElement('#hide-button').addEventListener('click', () => activeRuntime?.hide());
-    elements.macAppButton.addEventListener('click', () => void openMacApp());
-    elements.copyDebugPageUrlButton.addEventListener('click', () => void copyDebugPageUrl());
     elements.mobileLanSelect.addEventListener('change', () => void updateMobileQrCode());
-    elements.networkPermissionSelect.addEventListener('change', () => {
-        void savePermissionOverride(elements.networkPermissionSelect.value === 'enabled' ? 'enabled' : 'disabled');
-    });
-    elements.resetPermissionsButton.addEventListener('click', () => void resetPermissionOverride());
 }
 async function restartRuntime(reason) {
     const generation = ++runtimeGeneration;
     destroyActiveRuntime(reason);
-    elements.bridgeStatus.textContent = 'starting';
+    runtimePermissionState = clonePermissionState(permissionState);
     elements.device.replaceChildren();
+    if (uiPreview) {
+        elements.device.innerHTML = '<div class="placeholder">未加载小程序</div>';
+        return;
+    }
     const iframe = document.createElement('iframe');
     iframe.allow = 'clipboard-read; clipboard-write';
     elements.device.appendChild(iframe);
@@ -10292,11 +11415,10 @@ async function restartRuntime(reason) {
             resolveLaunchConfiguration: async () => (await assembly.resolveLaunch()).configuration,
             dispose: assembly.dispose,
             onReady: () => {
-                elements.bridgeStatus.textContent = 'ready';
                 pushLog('runtime.ready', { generation });
             },
             onStateChange: (state) => {
-                elements.bridgeStatus.textContent = state;
+                pushLog('runtime.state', { generation, state });
             },
             onError: (error) => pushLog('runtime.error', redactNetworkLogValue(error)),
             onSecurityViolation: (event) => pushLog('runtime.security', redactNetworkLogValue(event)),
@@ -10307,7 +11429,6 @@ async function restartRuntime(reason) {
     catch (error) {
         if (disposed || generation !== runtimeGeneration || terminal.signal.aborted)
             return;
-        elements.bridgeStatus.textContent = 'failed';
         pushLog('runtime.start.failed', redactNetworkLogValue(error));
     }
 }
@@ -10316,13 +11437,10 @@ function createWebHostInput(signal) {
         signal,
         account: {
             async getCurrentUserId() {
-                return (await refreshSessionStatus(false)).user_id;
+                return (await refreshSessionStatus(false, signal)).user_id;
             },
             async ensureAuthenticated({ signal: operationSignal }) {
-                if ((await refreshSessionStatus(false)).authenticated)
-                    return;
-                await beginLogin();
-                await waitForAbort(operationSignal);
+                await refreshSessionStatus(false, operationSignal);
             },
             onChange(listener) {
                 accountListeners.add(listener);
@@ -10331,29 +11449,12 @@ function createWebHostInput(signal) {
         },
         authenticatedRequest: requestFromWebHost,
         storage: { area: 'local', storage: localStorage },
-        presentation: {
-            close: async () => activeRuntime?.destroy(),
-            reload: async () => location.reload(),
-            getViewportMetrics: () => ({
-                windowWidth: window.innerWidth,
-                windowHeight: window.innerHeight,
-                screenWidth: window.screen.width,
-                screenHeight: window.screen.height,
-                pixelRatio: window.devicePixelRatio,
-            }),
-            getNavigationBarHeight: () => 0,
-            setNavigationBarStyle: (style) => {
-                document.documentElement.dataset.navigationBarStyle = style;
-            },
-            showToast: async ({ message, status }) => showTransientMessage(message, status),
-            showLoading: async () => {
-                elements.bridgeStatus.textContent = 'loading';
-            },
-            hideLoading: async () => {
-                elements.bridgeStatus.textContent = activeRuntime?.state ?? 'idle';
+        presentation: createBrowserDevHostPresentation({
+            close: async () => {
+                activeRuntime?.destroy();
             },
-            setClipboard: async ({ text }) => navigator.clipboard.writeText(text),
-        },
+            pushLog,
+        }),
         environment: {
             getCurrentHref: () => location.href,
             isDevRuntime: () => true,
@@ -10370,11 +11471,7 @@ function createWebHostInput(signal) {
             hostHints: { launchKind: devContext.source === 'remote' ? 'dev-session' : 'anonymous-local-dev' },
         }),
         authPresentation: {
-            async confirmAuthorization({ scopes, signal: operationSignal }) {
-                if (operationSignal.aborted)
-                    throw operationSignal.reason;
-                return window.confirm(`允许小程序访问 ${scopes.join('、')}？`) ? { status: 'granted', grantedScopes: scopes } : { status: 'cancelled' };
-            },
+            confirmAuthorization: (request) => confirmBrowserDevHostAuthorization(request),
         },
     };
 }
@@ -10404,44 +11501,82 @@ async function requestFromWebHost(request) {
         signal: request.signal,
     });
     if (!anonymousPayload && response.status === 401) {
-        void handleAccountRevision().catch(handleSessionNavigationError);
+        void accountStatusDrain.invalidate();
     }
     const payload = (await response.json());
     if (!response.ok)
         throw payload;
     return payload;
 }
-async function beginLogin() {
-    if ((await refreshSessionStatus(false)).authenticated)
-        return;
-    const response = await requestJson(SESSION_LOGIN_INTENT_PATH, {
-        method: 'POST',
-        body: JSON.stringify({ return_path: `${location.pathname}${location.search}` }),
+async function refreshSessionStatus(notify, signal) {
+    const generation = hostGeneration;
+    const status = await fetchSessionStatus(combineAbortSignals(hostAbortController.signal, signal));
+    if (!isActiveHostGeneration(generation))
+        return currentSessionStatus();
+    return applySessionStatus(status, notify).status;
+}
+async function fetchSessionStatus(signal) {
+    const response = await fetch(SESSION_STATUS_PATH, {
+        cache: 'no-store',
+        credentials: 'same-origin',
+        redirect: 'error',
+        signal,
     });
-    const payload = (await response.json());
-    if (!response.ok || typeof payload.authorization_url !== 'string') {
-        const unavailable = payload.code === 'LOGIN_SERVICE_UNAVAILABLE';
-        throw new Error(unavailable ? 'Browser Dev Host 登录服务尚未配置' : '登录启动失败');
-    }
-    location.assign(payload.authorization_url);
-}
-async function logout() {
-    const response = await requestJson(SESSION_LOGOUT_PATH, { method: 'POST', body: '{}' });
-    if (!response.ok)
-        showTransientMessage('退出登录失败', 'error');
-    else
-        await handleAccountRevision();
-}
-async function refreshSessionStatus(notify) {
-    const response = await fetch(SESSION_STATUS_PATH, { cache: 'no-store', credentials: 'same-origin', redirect: 'error' });
-    const status = (await response.json());
-    const changed = status.revision !== sessionRevision || status.user_id !== sessionUserId;
+    return (await response.json());
+}
+function applySessionStatus(status, notify) {
+    if (!Number.isSafeInteger(status.revision) || status.revision < sessionRevision) {
+        return { changed: false, status: currentSessionStatus() };
+    }
+    const nextUserId = status.authenticated ? status.user_id : undefined;
+    const nextNickname = status.authenticated ? readOptionalText(status.nickname) : undefined;
+    const nextAvatar = status.authenticated ? readOptionalText(status.avatar) : undefined;
+    const changed = status.revision !== sessionRevision ||
+        status.authenticated !== sessionAuthenticated ||
+        nextUserId !== sessionUserId ||
+        nextNickname !== sessionUserNickname ||
+        nextAvatar !== sessionUserAvatar;
     sessionRevision = status.revision;
-    sessionUserId = status.authenticated ? status.user_id : undefined;
-    updateUserStatus();
+    sessionAuthenticated = status.authenticated;
+    sessionUserId = nextUserId;
+    sessionUserNickname = nextNickname;
+    sessionUserAvatar = nextAvatar;
+    renderDeveloperAccount();
     if (notify && changed)
         accountListeners.forEach((listener) => listener(sessionUserId));
-    return status;
+    return { changed, status: currentSessionStatus() };
+}
+function currentSessionStatus() {
+    return {
+        authenticated: sessionAuthenticated,
+        revision: sessionRevision,
+        ...(sessionAuthenticated && sessionUserId ? { user_id: sessionUserId } : {}),
+    };
+}
+function connectBrowserChannel() {
+    if (!bootstrap.csrfToken || disposed)
+        return;
+    try {
+        const channelUrl = new URL('/__hb_sdk__/channel', location.href);
+        channelUrl.protocol = channelUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+        channelClient = createBrowserDevHostChannelClient({
+            csrfToken: bootstrap.csrfToken,
+            onDiagnostic: (diagnostic) => pushLog('channel.diagnostic', diagnostic),
+            url: channelUrl.toString(),
+        });
+        channelClient.subscribeUpdates((snapshot, update) => applyBrowserChannelSnapshot(snapshot, update));
+        channelClient.connect();
+    }
+    catch {
+        channelClient?.dispose();
+        channelClient = undefined;
+    }
+}
+function applyBrowserChannelSnapshot(snapshot, update) {
+    void accountStatusDrain.invalidate(snapshot.account.revision);
+    void permissionStatusDrain.invalidate(snapshot.permissions, {
+        force: update.type === 'event' && update.event === 'status.changed',
+    });
 }
 function connectSessionEvents() {
     sessionEventSource?.close();
@@ -10450,52 +11585,20 @@ function connectSessionEvents() {
         return;
     const source = new EventSource(SESSION_EVENTS_PATH, { withCredentials: true });
     sessionEventSource = source;
-    source.addEventListener('account-invalidated', () => void handleAccountRevision().catch(handleSessionNavigationError));
-    source.addEventListener('account-revision', () => void handleAccountRevision().catch(handleSessionNavigationError));
+    source.addEventListener('account-invalidated', () => void accountStatusDrain.invalidate());
+    source.addEventListener('account-revision', () => void accountStatusDrain.invalidate());
     source.onopen = () => {
-        sessionPollDelay = SESSION_POLL_MIN_MS;
-        clearSessionPoll();
+        accountStatusPoll.reset();
     };
     source.onerror = () => {
         source.close();
-        scheduleSessionPoll();
+        accountStatusPoll.schedule();
     };
 }
-function handleAccountRevision() {
-    accountRevisionTask ?? (accountRevisionTask = processAccountRevision().finally(() => {
-        accountRevisionTask = undefined;
-    }));
-    return accountRevisionTask;
-}
-async function processAccountRevision() {
-    const previousRevision = sessionRevision;
-    const status = await refreshSessionStatus(true);
-    if (status.revision === previousRevision)
+async function reconcileAccountRevision(generation) {
+    if (!isActiveHostGeneration(generation))
         return;
-    destroyActiveRuntime('account revision changed');
-    if (status.authenticated)
-        await restartRuntime('account revision changed');
-    else
-        await beginLogin();
-}
-function scheduleSessionPoll() {
-    clearSessionPoll();
-    sessionPollTimer = window.setTimeout(async () => {
-        try {
-            await handleAccountRevision();
-            sessionPollDelay = SESSION_POLL_MIN_MS;
-            connectSessionEvents();
-        }
-        catch {
-            sessionPollDelay = Math.min(sessionPollDelay * 2, SESSION_POLL_MAX_MS);
-            scheduleSessionPoll();
-        }
-    }, sessionPollDelay);
-}
-function clearSessionPoll() {
-    if (sessionPollTimer !== undefined)
-        window.clearTimeout(sessionPollTimer);
-    sessionPollTimer = undefined;
+    await restartRuntime('account revision changed');
 }
 function destroyActiveRuntime(reason) {
     activeRuntime?.destroy();
@@ -10507,76 +11610,12 @@ function destroyActiveRuntime(reason) {
 }
 async function loadPersistedPermissionConfiguration() {
     try {
-        const response = await fetch(DEV_PERMISSIONS_PATH, { cache: 'no-store', credentials: 'same-origin', redirect: 'error' });
-        const configuration = readPermissionConfiguration(await response.json());
-        if (!response.ok || !configuration)
-            throw new Error('权限持久化配置加载失败');
+        const configuration = await fetchPermissionConfiguration(hostAbortController.signal);
         applyPermissionConfiguration(configuration);
     }
     catch {
-        permissionActionMessage = '权限持久化暂不可用，刷新或重启后可能丢失本页修改。';
-    }
-}
-async function savePermissionOverride(status) {
-    setPermissionControlsDisabled(true);
-    permissionState = { networkRequest: { ...permissionState.networkRequest, status } };
-    hasPermissionOverride = true;
-    permissionActionMessage = '正在保存本地权限覆盖...';
-    updatePermissionControls();
-    try {
-        const response = await requestJson(DEV_PERMISSIONS_PATH, {
-            method: 'PUT',
-            body: JSON.stringify({ runtime_permissions: createBrowserDevRuntimePermissions(permissionState) }),
-        });
-        const configuration = readPermissionConfiguration(await response.json());
-        if (!response.ok || !configuration)
-            throw new Error('保存失败');
-        applyPermissionConfiguration(configuration, configuration.persistenceError || '本地权限覆盖已保存。');
-        await restartRuntime('permission changed');
-        void updateMobileQrCode();
-    }
-    catch (error) {
-        permissionActionMessage = `${readErrorText(error)}，当前页面仍会应用该权限，但刷新或重启后会丢失。`;
-    }
-    finally {
-        setPermissionControlsDisabled(false);
-        updatePermissionControls();
-    }
-}
-async function resetPermissionOverride() {
-    setPermissionControlsDisabled(true);
-    try {
-        const response = await requestJson(DEV_PERMISSIONS_PATH, { method: 'DELETE', body: '{}' });
-        const configuration = readPermissionConfiguration(await response.json());
-        if (!response.ok || !configuration)
-            throw new Error('重置失败');
-        applyPermissionConfiguration(configuration, configuration.source === 'remote' ? '已重新读取远端权限并清除本地覆盖。' : '已清除本地权限覆盖。');
-        await restartRuntime('permission reset');
-        void updateMobileQrCode();
+        /* 权限覆盖读取失败时继续使用当前内存态。 */
     }
-    catch (error) {
-        permissionActionMessage = `重置失败：${readErrorText(error)}`;
-    }
-    finally {
-        setPermissionControlsDisabled(false);
-        updatePermissionControls();
-    }
-}
-function updatePermissionControls() {
-    elements.devContextStatus.textContent =
-        devContext.source === 'remote' ? `已连接线上配置${devContext.miniProgramId ? ` · ${devContext.miniProgramId}` : ''}` : '匿名本地沙箱';
-    elements.networkPermissionSelect.value = permissionState.networkRequest.status;
-    const remoteLabel = readPermissionStatusLabel(remotePermissionState.networkRequest.status);
-    const localLabel = readPermissionStatusLabel(permissionState.networkRequest.status);
-    const sourceDescription = hasPermissionOverride
-        ? `远端基线：${remoteLabel} · 本地覆盖：${localLabel}`
-        : `${devContext.source === 'remote' ? '当前使用远端权限' : '当前使用匿名默认权限'}：${remoteLabel}`;
-    elements.permissionPersistenceStatus.textContent = permissionActionMessage
-        ? `${sourceDescription} · ${permissionActionMessage}`
-        : sourceDescription;
-    elements.releaseDiagnostics.innerHTML = createMiniProgramDevReleaseDiagnostics(devContext, permissionState)
-        .map((diagnostic) => `<li>${escapeHtml(diagnostic.message)}</li>`)
-        .join('');
 }
 function readPermissionConfiguration(value) {
     if (!isRecord(value) || (value.source !== 'anonymous' && value.source !== 'remote'))
@@ -10593,15 +11632,33 @@ function readPermissionConfiguration(value) {
         persistenceError: typeof value.persistence_error === 'string' ? value.persistence_error : undefined,
     };
 }
-function applyPermissionConfiguration(configuration, message) {
+async function fetchPermissionConfiguration(signal) {
+    const response = await fetch(DEV_PERMISSIONS_PATH, {
+        cache: 'no-store',
+        credentials: 'same-origin',
+        redirect: 'error',
+        signal,
+    });
+    const configuration = readPermissionConfiguration(await response.json());
+    if (!response.ok || !configuration)
+        throw new Error('权限持久化配置加载失败');
+    return configuration;
+}
+function applyPermissionConfiguration(configuration) {
     devContext =
         configuration.source === 'remote'
             ? { source: 'remote', miniProgramId: configuration.miniProgramId, runtimePermissions: configuration.remotePermissions }
             : { source: 'anonymous', warning: devContext.warning };
     remotePermissionState = clonePermissionState(configuration.remoteState);
     permissionState = clonePermissionState(configuration.overrideState ?? configuration.remoteState);
-    hasPermissionOverride = Boolean(configuration.overrideState);
-    permissionActionMessage = message ?? configuration.persistenceError ?? '';
+}
+async function refreshRuntimeForCanonicalPermission() {
+    if (disposed)
+        return;
+    await restartRuntime('permission changed');
+    if (disposed)
+        return;
+    await updateMobileQrCode();
 }
 async function loadBootstrap() {
     const response = await fetch(BOOTSTRAP_PATH, { cache: 'no-store', credentials: 'same-origin', redirect: 'error' });
@@ -10610,6 +11667,10 @@ async function loadBootstrap() {
     const value = await response.json();
     if (!isRecord(value))
         throw new Error('Browser Dev Host bootstrap is invalid');
+    const mobileLaunchRedirect = readMobileLaunchRedirectEntry(value.mobileLaunchRedirect);
+    if (Object.hasOwn(value, 'mobileLaunchRedirect') && value.mobileLaunchRedirect !== undefined && !mobileLaunchRedirect) {
+        throw new InvalidMobileLaunchRedirectError();
+    }
     return {
         csrfToken: typeof value.csrfToken === 'string' ? value.csrfToken : undefined,
         defaultLanAddressId: typeof value.defaultLanAddressId === 'string' ? value.defaultLanAddressId : undefined,
@@ -10617,6 +11678,8 @@ async function loadBootstrap() {
         lanAddresses: Array.isArray(value.lanAddresses) ? value.lanAddresses.filter(isLanAddress) : [],
         loginAvailable: value.loginAvailable === true,
         macAppProtocol: typeof value.macAppProtocol === 'string' ? value.macAppProtocol : undefined,
+        miniProgram: readMiniProgramSummary(value.miniProgram),
+        mobileLaunchRedirect,
         nativeAppLaunchUnavailableReason: typeof value.nativeAppLaunchUnavailableReason === 'string' ? value.nativeAppLaunchUnavailableReason : undefined,
     };
 }
@@ -10643,7 +11706,7 @@ async function setupMobileAppQr() {
     setupMobileLanSelect();
     await updateMobileQrCode();
 }
-function setupMobileLanSelect() {
+function setupMobileLanSelect(preferredLanAddressId = elements.mobileLanSelect.options.length > 0 ? elements.mobileLanSelect.value : undefined) {
     elements.mobileLanSelect.replaceChildren();
     for (const address of lanAddresses) {
         const option = document.createElement('option');
@@ -10651,8 +11714,15 @@ function setupMobileLanSelect() {
         option.textContent = `${address.name} · ${address.address}`;
         elements.mobileLanSelect.appendChild(option);
     }
-    if (defaultLanAddressId && lanAddresses.some(({ id }) => id === defaultLanAddressId))
+    if (preferredLanAddressId && lanAddresses.some(({ id }) => id === preferredLanAddressId)) {
+        elements.mobileLanSelect.value = preferredLanAddressId;
+    }
+    else if (defaultLanAddressId && lanAddresses.some(({ id }) => id === defaultLanAddressId)) {
         elements.mobileLanSelect.value = defaultLanAddressId;
+    }
+    else if (lanAddresses[0]) {
+        elements.mobileLanSelect.value = lanAddresses[0].id;
+    }
     elements.mobileLanSelect.disabled = lanAddresses.length === 0;
 }
 async function updateMobileQrCode() {
@@ -10671,21 +11741,101 @@ async function updateMobileQrCode() {
         const devSession = await createMobileDevSession(selected);
         if (generation !== mobileQrGeneration || disposed)
             return;
-        const payload = applyDevContextToMobileQrPayload(selected.mobileAppQrPayload, devSession.url);
-        const imageUrl = await browserExports.toDataURL(payload, { width: MOBILE_QR_IMAGE_SIZE, margin: 1 });
+        const qr = await resolveDisplayedMobileQr(devSession.address, devSession.expiresAt);
+        if (generation !== mobileQrGeneration || disposed)
+            return;
+        const imageUrl = await browserExports.toDataURL(qr.payload, { width: MOBILE_QR_IMAGE_SIZE, margin: 1 });
         if (generation !== mobileQrGeneration || disposed)
             return;
         elements.mobileQrImage.src = imageUrl;
-        elements.mobileQrStatus.textContent = `${selected.name} · ${selected.address}`;
-        scheduleMobileQrRefresh(devSession.expiresAt, generation);
+        elements.mobileQrStatus.textContent = `${devSession.address.name} · ${devSession.address.address}`;
+        scheduleMobileQrRefresh(qr.expiresAt, generation);
     }
     catch (error) {
         if (generation !== mobileQrGeneration || disposed)
             return;
+        if (error instanceof InvalidMobileLaunchRedirectError) {
+            invalidateMobileLaunchRedirectQr();
+            return;
+        }
         elements.mobileQrImage.removeAttribute('src');
         elements.mobileQrStatus.textContent = readErrorText(error);
     }
 }
+async function resolveDisplayedMobileQr(address, sessionExpiresAt) {
+    const payload = address.mobileAppQrPayload;
+    if (!payload)
+        throw new Error('Mobile 启动配置不可用');
+    const redirect = await ensureMobileLaunchRedirect(address, payload);
+    if (!redirect) {
+        return { expiresAt: sessionExpiresAt, payload };
+    }
+    try {
+        return {
+            expiresAt: Math.min(sessionExpiresAt, redirect.expiresAt),
+            payload: createMobileAppRedirectQrPayload(createMobileLaunchRedirectHttpUrl({
+                host: address.address,
+                port: location.port,
+                token: redirect.token,
+            })),
+        };
+    }
+    catch {
+        throw new InvalidMobileLaunchRedirectError();
+    }
+}
+async function ensureMobileLaunchRedirect(address, payload) {
+    if (mobileLaunchRedirect?.addressId === address.id)
+        return mobileLaunchRedirect;
+    if (!mobileLaunchRedirect)
+        return undefined;
+    const response = await requestJson(MOBILE_LAUNCH_REDIRECT_PATH, {
+        method: 'POST',
+        body: JSON.stringify({
+            address_id: address.id,
+            payload,
+            previous_token: mobileLaunchRedirect.token,
+        }),
+    });
+    if (!response.ok)
+        throw new InvalidMobileLaunchRedirectError();
+    const value = await response.json();
+    const entry = isRecord(value)
+        ? readMobileLaunchRedirectEntry({
+            addressId: value.address_id,
+            expiresAt: value.expires_at,
+            token: value.token,
+        })
+        : undefined;
+    if (!entry || entry.addressId !== address.id)
+        throw new InvalidMobileLaunchRedirectError();
+    mobileLaunchRedirect = entry;
+    return entry;
+}
+async function reloadNativeLaunchConfigForDevSession(selectedAddressId) {
+    const latest = await loadBootstrap();
+    const address = readLatestLanAddress(latest, selectedAddressId);
+    const payload = address?.mobileAppQrPayload;
+    if (!address || !payload)
+        throw new Error('Mobile 启动配置不可用');
+    applyLatestNativeLaunchConfig(latest);
+    return { ...address, mobileAppQrPayload: payload };
+}
+function readLatestLanAddress(latest, selectedAddressId) {
+    return (latest.lanAddresses.find(({ id }) => id === selectedAddressId) ??
+        latest.lanAddresses.find(({ id }) => id === latest.defaultLanAddressId) ??
+        latest.lanAddresses[0]);
+}
+function applyLatestNativeLaunchConfig(latest) {
+    nativeLaunchConfigSignature = readNativeLaunchConfigSignature(latest);
+    lanAddresses = latest.lanAddresses;
+    defaultLanAddressId = latest.defaultLanAddressId;
+    mobileLaunchRedirect = latest.mobileLaunchRedirect;
+    renderMiniProgramSummary(resolveDisplayedMiniProgram(latest));
+    setupMobileLanSelect();
+}
+class InvalidMobileLaunchRedirectError extends Error {
+}
 async function createMobileDevSession(selected) {
     const creation = mobileDevSessionCreation.then(() => requestMobileDevSession(selected));
     mobileDevSessionCreation = creation.then(() => undefined, () => undefined);
@@ -10693,22 +11843,20 @@ async function createMobileDevSession(selected) {
 }
 async function requestMobileDevSession(selected) {
     const hostUrl = new URL(selected.appUrl);
-    const devContextUrl = new URL(MINI_PROGRAM_DEV_CONTEXT_PATH, location.origin);
-    const response = await requestJson(devContextUrl.pathname, {
+    const endpointUrl = new URL(MINI_PROGRAM_DEV_CONTEXT_PATH, location.origin);
+    const response = await requestJson(endpointUrl.pathname, {
         method: 'POST',
-        body: JSON.stringify({ mini_url_origin: hostUrl.origin, runtime_permissions: createBrowserDevRuntimePermissions(permissionState) }),
+        body: JSON.stringify({
+            mini_url_origin: hostUrl.origin,
+            runtime_permissions: createMobileDevSessionRuntimePermissions(permissionState),
+        }),
     });
     const value = await response.json();
     if (!response.ok || !isRecord(value) || typeof value.token !== 'string' || typeof value.expires_at !== 'number') {
         throw new Error('创建 Mobile Dev Session 失败');
     }
-    devContextUrl.pathname = `${MINI_PROGRAM_DEV_CONTEXT_PATH}/${value.token}`;
-    return { url: devContextUrl.toString(), expiresAt: value.expires_at };
-}
-function applyDevContextToMobileQrPayload(payload, devContextUrl) {
-    const target = new URL(payload);
-    target.searchParams.set(MINI_PROGRAM_DEV_CONTEXT_QUERY_PARAM, devContextUrl);
-    return target.toString();
+    const latest = await reloadNativeLaunchConfigForDevSession(selected.id);
+    return { address: latest, expiresAt: value.expires_at };
 }
 function scheduleMobileQrRefresh(expiresAt, generation) {
     mobileQrRefreshTimer = window.setTimeout(() => {
@@ -10725,51 +11873,112 @@ async function refreshNativeLaunchConfig() {
         const signature = readNativeLaunchConfigSignature(latest);
         if (signature === nativeLaunchConfigSignature)
             return;
-        nativeLaunchConfigSignature = signature;
-        lanAddresses = latest.lanAddresses;
-        defaultLanAddressId = latest.defaultLanAddressId;
-        macAppProtocol = latest.macAppProtocol;
-        nativeAppLaunchUnavailableReason = latest.nativeAppLaunchUnavailableReason;
-        setupMobileLanSelect();
-        updateNativeAppLaunchAvailability();
+        applyLatestNativeLaunchConfig(latest);
         void updateMobileQrCode();
     }
+    catch (error) {
+        if (error instanceof InvalidMobileLaunchRedirectError)
+            invalidateMobileLaunchRedirectQr();
+    }
     finally {
         nativeLaunchConfigRefreshInFlight = false;
     }
 }
+function invalidateMobileLaunchRedirectQr() {
+    mobileQrGeneration += 1;
+    clearMobileQrRefreshTimer();
+    elements.mobileQrImage.removeAttribute('src');
+    elements.mobileQrStatus.textContent = 'Mobile 短链接配置无效';
+}
 function readNativeLaunchConfigSignature(value) {
     return JSON.stringify({
         defaultLanAddressId: value.defaultLanAddressId,
         lanAddresses: value.lanAddresses,
         macAppProtocol: value.macAppProtocol,
+        mobileLaunchRedirect: value.mobileLaunchRedirect
+            ? {
+                addressId: value.mobileLaunchRedirect.addressId,
+                expiresAt: value.mobileLaunchRedirect.expiresAt,
+                token: value.mobileLaunchRedirect.token,
+            }
+            : undefined,
         nativeAppLaunchUnavailableReason: value.nativeAppLaunchUnavailableReason,
     });
 }
-async function openMacApp() {
-    if (macAppProtocol)
-        location.href = macAppProtocol;
-    showMacAppLaunchHint();
-}
-function showMacAppLaunchHint() {
-    elements.macAppStatus.hidden = false;
-    elements.debugPageUrl.textContent = location.href;
-}
-async function copyDebugPageUrl() {
-    await copyText(location.href);
-    elements.debugPageCopyStatus.textContent = '已复制';
-}
-function updateNativeAppLaunchAvailability() {
-    elements.macAppButton.disabled = !macAppProtocol;
-    elements.macAppButton.title = nativeAppLaunchUnavailableReason ?? '';
-}
-function updateUserStatus() {
-    applyBrowserDevLoginAvailability({
-        available: bootstrap.loginAvailable,
-        loginButton: elements.loginButton,
-        userId: sessionUserId,
-        userStatus: elements.userStatus,
-    });
+function renderDeveloperAccount() {
+    if (!sessionAuthenticated) {
+        elements.developerAvatar.hidden = true;
+        elements.developerAvatar.removeAttribute('src');
+        elements.developerName.textContent = '未登录';
+        elements.developerHint.textContent = '请运行 hb-sdk login';
+        return;
+    }
+    elements.developerName.textContent = sessionUserNickname || sessionUserId || '已登录';
+    elements.developerHint.textContent = sessionUserId ? `heybox_id ${sessionUserId}` : '';
+    if (sessionUserAvatar) {
+        elements.developerAvatar.hidden = false;
+        elements.developerAvatar.src = sessionUserAvatar;
+        elements.developerAvatar.alt = elements.developerName.textContent;
+    }
+    else {
+        elements.developerAvatar.hidden = true;
+        elements.developerAvatar.removeAttribute('src');
+        elements.developerAvatar.alt = '';
+    }
+}
+function resolveDisplayedMiniProgram(source) {
+    if (source.miniProgram?.miniProgramId)
+        return source.miniProgram;
+    const miniProgramId = source.devContext.miniProgramId?.trim();
+    return miniProgramId ? { miniProgramId } : source.miniProgram ?? null;
+}
+function renderMiniProgramSummary(summary) {
+    const bound = Boolean(summary?.miniProgramId);
+    elements.miniProgramSummary.hidden = !bound;
+    elements.miniProgramEmpty.hidden = bound;
+    if (!bound || !summary) {
+        elements.miniProgramIcon.hidden = true;
+        elements.miniProgramIcon.removeAttribute('src');
+        elements.miniProgramName.textContent = '';
+        elements.miniProgramId.textContent = '';
+        return;
+    }
+    elements.miniProgramName.textContent = summary.name || summary.miniProgramId;
+    elements.miniProgramId.textContent = [summary.miniProgramId, summary.version, summary.status].filter(Boolean).join(' · ');
+    if (summary.iconUrl) {
+        elements.miniProgramIcon.hidden = false;
+        elements.miniProgramIcon.src = summary.iconUrl;
+        elements.miniProgramIcon.alt = summary.name || summary.miniProgramId;
+    }
+    else {
+        elements.miniProgramIcon.hidden = true;
+        elements.miniProgramIcon.removeAttribute('src');
+        elements.miniProgramIcon.alt = '';
+    }
+}
+function readMiniProgramSummary(value) {
+    if (value === null)
+        return null;
+    if (!isRecord(value))
+        return undefined;
+    const miniProgramId = readOptionalText(value.miniProgramId) ?? readOptionalText(value.mini_program_id);
+    if (!miniProgramId)
+        return undefined;
+    return {
+        miniProgramId,
+        ...(readOptionalText(value.name) ? { name: readOptionalText(value.name) } : {}),
+        ...(readOptionalText(value.iconUrl) ?? readOptionalText(value.icon_url)
+            ? { iconUrl: readOptionalText(value.iconUrl) ?? readOptionalText(value.icon_url) }
+            : {}),
+        ...(readOptionalText(value.status) ? { status: readOptionalText(value.status) } : {}),
+        ...(readOptionalText(value.version) ? { version: readOptionalText(value.version) } : {}),
+        ...(readOptionalText(value.developerName) ?? readOptionalText(value.developer_name)
+            ? { developerName: readOptionalText(value.developerName) ?? readOptionalText(value.developer_name) }
+            : {}),
+    };
+}
+function readOptionalText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 function updateStorageSnapshot() {
     const snapshot = {};
@@ -10784,6 +11993,8 @@ function showTransientMessage(message, status) {
     pushLog('host.message', { message, status });
 }
 function handleSessionNavigationError(error) {
+    if (disposed)
+        return;
     showTransientMessage(readErrorText(error), 'error');
 }
 function pushLog(method, detail) {
@@ -10798,10 +12009,16 @@ function disposeBrowserDevHost() {
     if (disposed)
         return;
     disposed = true;
+    hostGeneration += 1;
+    hostAbortController.abort(new DOMException('Browser Dev Host disposed', 'AbortError'));
+    accountStatusDrain.dispose();
+    permissionStatusDrain.dispose();
     runtimeGeneration += 1;
     destroyActiveRuntime('Browser Dev Host disposed');
     sessionEventSource?.close();
-    clearSessionPoll();
+    channelClient?.dispose();
+    channelClient = undefined;
+    accountStatusPoll.dispose();
     clearMobileQrRefreshTimer();
     if (nativeLaunchConfigRefreshTimer !== undefined)
         window.clearInterval(nativeLaunchConfigRefreshTimer);
@@ -10812,12 +12029,11 @@ function clearMobileQrRefreshTimer() {
         window.clearTimeout(mobileQrRefreshTimer);
     mobileQrRefreshTimer = undefined;
 }
-function waitForAbort(signal) {
-    if (signal.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((_resolve, reject) => {
-        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-    });
+function combineAbortSignals(primary, secondary) {
+    return secondary ? AbortSignal.any([primary, secondary]) : primary;
+}
+function isActiveHostGeneration(generation) {
+    return !disposed && generation === hostGeneration;
 }
 function readSelectedLanAddress() {
     return lanAddresses.find(({ id }) => id === elements.mobileLanSelect.value);
@@ -10830,25 +12046,23 @@ function isLanAddress(value) {
         typeof value.name === 'string' &&
         (value.mobileAppQrPayload === undefined || typeof value.mobileAppQrPayload === 'string'));
 }
-async function copyText(value) {
-    if (navigator.clipboard?.writeText)
-        return navigator.clipboard.writeText(value);
-    const textarea = document.createElement('textarea');
-    textarea.value = value;
-    document.body.appendChild(textarea);
-    textarea.select();
-    document.execCommand('copy');
-    textarea.remove();
-}
-function setPermissionControlsDisabled(disabled) {
-    elements.networkPermissionSelect.disabled = disabled;
-    elements.resetPermissionsButton.disabled = disabled;
+function readMobileLaunchRedirectEntry(value) {
+    if (!isRecord(value) ||
+        typeof value.addressId !== 'string' ||
+        !value.addressId ||
+        typeof value.expiresAt !== 'number' ||
+        !Number.isFinite(value.expiresAt) ||
+        typeof value.token !== 'string' ||
+        !/^[A-Za-z0-9_-]{22}$/.test(value.token)) {
+        return undefined;
+    }
+    return { addressId: value.addressId, expiresAt: value.expiresAt, token: value.token };
 }
 function clonePermissionState(state) {
     return { networkRequest: { ...state.networkRequest } };
 }
-function readPermissionStatusLabel(status) {
-    return status === 'enabled' ? '允许' : '拒绝';
+function isSamePermissionState(left, right) {
+    return (left.networkRequest.status === right.networkRequest.status && left.networkRequest.useOfficialDomain === right.networkRequest.useOfficialDomain);
 }
 function readErrorText(error) {
     return error instanceof Error && error.message ? error.message : '操作失败';