@heybox/hb-sdk 0.7.4-alpha.4 → 0.7.4-alpha.6

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

@@ -2,6 +2,7 @@ const AUTH_LOGIN_METHOD = 'auth.login';
 const USER_GET_INFO_METHOD = 'user.getInfo';
 const USER_REVOKE_AUTHORIZATION_METHOD = 'user.revokeAuthorization';
 const USER_GET_STEAM_GAME_LIST_METHOD = 'user.getSteamGameList';
+const SHARE_COPY_LINK_METHOD = 'share.copyLink';
 const SHARE_SHOW_SHARE_MENU_METHOD = 'share.showShareMenu';
 const SHARE_SCREENSHOT_METHOD = 'share.screenshot';
 const VIEWPORT_GET_WINDOW_INFO_METHOD = 'viewport.getWindowInfo';
@@ -39,6 +40,7 @@ const MINI_PROGRAM_PROTOCOL_CAPABILITIES = [
         permission: 'user.platformAccount.steam',
         risk: 'high',
     },
+    { method: SHARE_COPY_LINK_METHOD, module: 'share', capability: SHARE_COPY_LINK_METHOD, permission: 'share.copyLink', risk: 'medium' },
     { method: SHARE_SHOW_SHARE_MENU_METHOD, module: 'share', capability: SHARE_SHOW_SHARE_MENU_METHOD, permission: 'share.basic', risk: 'low' },
     { method: SHARE_SCREENSHOT_METHOD, module: 'share', capability: SHARE_SCREENSHOT_METHOD, permission: 'share.screenshot', risk: 'medium' },
     {
@@ -445,6 +447,7 @@ const HOST_METHOD_PRIMITIVE_REQUIREMENTS = {
     [USER_GET_INFO_METHOD]: ['account.getCurrentUserId', 'account.onChange', 'network.request'],
     [USER_REVOKE_AUTHORIZATION_METHOD]: ['account.getCurrentUserId', 'account.onChange', 'network.request'],
     [USER_GET_STEAM_GAME_LIST_METHOD]: ['account.getCurrentUserId', 'account.onChange', 'network.request'],
+    [SHARE_COPY_LINK_METHOD]: ['presentation.setClipboard'],
     [SHARE_SHOW_SHARE_MENU_METHOD]: ['presentation.showShareMenu'],
     [SHARE_SCREENSHOT_METHOD]: ['presentation.getViewportMetrics', 'presentation.captureAndShare'],
     [VIEWPORT_GET_WINDOW_INFO_METHOD]: ['presentation.getViewportMetrics', 'presentation.getNavigationBarHeight'],
@@ -701,6 +704,7 @@ const userMiniprogramPublicDetailEndpoint = {
             ...(input.local_dev_launch_token ? { local_dev_launch_token: input.local_dev_launch_token } : {}),
             ...(input.entry ? { entry: input.entry } : {}),
             ...(input.h_src_parent ? { h_src_parent: input.h_src_parent } : {}),
+            ...(input.extra !== undefined ? { extra: input.extra } : {}),
         };
     },
     /**
@@ -2791,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;
 }
@@ -2807,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);
@@ -2880,6 +2884,1009 @@ function bridgeError$2(code, message) {
     return { code, message };
 }
 
+function utf8Count(str) {
+    const strLength = str.length;
+    let byteLength = 0;
+    let pos = 0;
+    while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            byteLength++;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            byteLength += 2;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    const extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                byteLength += 3;
+            }
+            else {
+                // 4-byte
+                byteLength += 4;
+            }
+        }
+    }
+    return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+    const strLength = str.length;
+    let offset = outputOffset;
+    let pos = 0;
+    while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            output[offset++] = value;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    const extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+            else {
+                // 4-byte
+                output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+        }
+        output[offset++] = (value & 0x3f) | 0x80;
+    }
+}
+// TextEncoder and TextDecoder are standardized in whatwg encoding:
+// https://encoding.spec.whatwg.org/
+// and available in all the modern browsers:
+// https://caniuse.com/textencoder
+// They are available in Node.js since v12 LTS as well:
+// https://nodejs.org/api/globals.html#textencoder
+const sharedTextEncoder = new TextEncoder();
+// This threshold should be determined by benchmarking, which might vary in engines and input data.
+// Run `npx ts-node benchmark/encode-string.ts` for details.
+const TEXT_ENCODER_THRESHOLD = 50;
+function utf8EncodeTE(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+function utf8Encode(str, output, outputOffset) {
+    if (str.length > TEXT_ENCODER_THRESHOLD) {
+        utf8EncodeTE(str, output, outputOffset);
+    }
+    else {
+        utf8EncodeJs(str, output, outputOffset);
+    }
+}
+const CHUNK_SIZE = 4096;
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+    let offset = inputOffset;
+    const end = offset + byteLength;
+    const units = [];
+    let result = "";
+    while (offset < end) {
+        const byte1 = bytes[offset++];
+        if ((byte1 & 0x80) === 0) {
+            // 1 byte
+            units.push(byte1);
+        }
+        else if ((byte1 & 0xe0) === 0xc0) {
+            // 2 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 6) | byte2);
+        }
+        else if ((byte1 & 0xf0) === 0xe0) {
+            // 3 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            const byte3 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+        }
+        else if ((byte1 & 0xf8) === 0xf0) {
+            // 4 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            const byte3 = bytes[offset++] & 0x3f;
+            const byte4 = bytes[offset++] & 0x3f;
+            let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+            if (unit > 0xffff) {
+                unit -= 0x10000;
+                units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                unit = 0xdc00 | (unit & 0x3ff);
+            }
+            units.push(unit);
+        }
+        else {
+            units.push(byte1);
+        }
+        if (units.length >= CHUNK_SIZE) {
+            result += String.fromCharCode(...units);
+            units.length = 0;
+        }
+    }
+    if (units.length > 0) {
+        result += String.fromCharCode(...units);
+    }
+    return result;
+}
+new TextDecoder();
+
+/**
+ * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+ */
+class ExtData {
+    type;
+    data;
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+}
+
+class DecodeError extends Error {
+    constructor(message) {
+        super(message);
+        // fix the prototype chain in a cross-platform way
+        const proto = Object.create(DecodeError.prototype);
+        Object.setPrototypeOf(this, proto);
+        Object.defineProperty(this, "name", {
+            configurable: true,
+            enumerable: false,
+            value: DecodeError.name,
+        });
+    }
+}
+
+// Integer Utility
+// DataView extension to handle int64 / uint64,
+// where the actual range is 53-bits integer (a.k.a. safe integer)
+function setUint64(view, offset, value) {
+    const high = value / 4294967296;
+    const low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+    const high = Math.floor(value / 4294967296);
+    const low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+    const high = view.getInt32(offset);
+    const low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+
+// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+const EXT_TIMESTAMP = -1;
+const TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+const TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+    if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+        // Here sec >= 0 && nsec >= 0
+        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+            // timestamp 32 = { sec32 (unsigned) }
+            const rv = new Uint8Array(4);
+            const view = new DataView(rv.buffer);
+            view.setUint32(0, sec);
+            return rv;
+        }
+        else {
+            // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
+            const secHigh = sec / 0x100000000;
+            const secLow = sec & 0xffffffff;
+            const rv = new Uint8Array(8);
+            const view = new DataView(rv.buffer);
+            // nsec30 | secHigh2
+            view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
+            // secLow32
+            view.setUint32(4, secLow);
+            return rv;
+        }
+    }
+    else {
+        // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+        const rv = new Uint8Array(12);
+        const view = new DataView(rv.buffer);
+        view.setUint32(0, nsec);
+        setInt64(view, 4, sec);
+        return rv;
+    }
+}
+function encodeDateToTimeSpec(date) {
+    const msec = date.getTime();
+    const sec = Math.floor(msec / 1e3);
+    const nsec = (msec - sec * 1e3) * 1e6;
+    // Normalizes { sec, nsec } to ensure nsec is unsigned.
+    const nsecInSec = Math.floor(nsec / 1e9);
+    return {
+        sec: sec + nsecInSec,
+        nsec: nsec - nsecInSec * 1e9,
+    };
+}
+function encodeTimestampExtension(object) {
+    if (object instanceof Date) {
+        const timeSpec = encodeDateToTimeSpec(object);
+        return encodeTimeSpecToTimestamp(timeSpec);
+    }
+    else {
+        return null;
+    }
+}
+function decodeTimestampToTimeSpec(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    // data may be 32, 64, or 96 bits
+    switch (data.byteLength) {
+        case 4: {
+            // timestamp 32 = { sec32 }
+            const sec = view.getUint32(0);
+            const nsec = 0;
+            return { sec, nsec };
+        }
+        case 8: {
+            // timestamp 64 = { nsec30, sec34 }
+            const nsec30AndSecHigh2 = view.getUint32(0);
+            const secLow32 = view.getUint32(4);
+            const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+            const nsec = nsec30AndSecHigh2 >>> 2;
+            return { sec, nsec };
+        }
+        case 12: {
+            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+            const sec = getInt64(view, 4);
+            const nsec = view.getUint32(0);
+            return { sec, nsec };
+        }
+        default:
+            throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+    }
+}
+function decodeTimestampExtension(data) {
+    const timeSpec = decodeTimestampToTimeSpec(data);
+    return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+const timestampExtension = {
+    type: EXT_TIMESTAMP,
+    encode: encodeTimestampExtension,
+    decode: decodeTimestampExtension,
+};
+
+// ExtensionCodec to handle MessagePack extensions
+class ExtensionCodec {
+    static defaultCodec = new ExtensionCodec();
+    // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+    // this will make type errors a lot more clear
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __brand;
+    // built-in extensions
+    builtInEncoders = [];
+    builtInDecoders = [];
+    // custom extensions
+    encoders = [];
+    decoders = [];
+    constructor() {
+        this.register(timestampExtension);
+    }
+    register({ type, encode, decode, }) {
+        if (type >= 0) {
+            // custom extensions
+            this.encoders[type] = encode;
+            this.decoders[type] = decode;
+        }
+        else {
+            // built-in extensions
+            const index = -1 - type;
+            this.builtInEncoders[index] = encode;
+            this.builtInDecoders[index] = decode;
+        }
+    }
+    tryToEncode(object, context) {
+        // built-in extensions
+        for (let i = 0; i < this.builtInEncoders.length; i++) {
+            const encodeExt = this.builtInEncoders[i];
+            if (encodeExt != null) {
+                const data = encodeExt(object, context);
+                if (data != null) {
+                    const type = -1 - i;
+                    return new ExtData(type, data);
+                }
+            }
+        }
+        // custom extensions
+        for (let i = 0; i < this.encoders.length; i++) {
+            const encodeExt = this.encoders[i];
+            if (encodeExt != null) {
+                const data = encodeExt(object, context);
+                if (data != null) {
+                    const type = i;
+                    return new ExtData(type, data);
+                }
+            }
+        }
+        if (object instanceof ExtData) {
+            // to keep ExtData as is
+            return object;
+        }
+        return null;
+    }
+    decode(data, type, context) {
+        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+            return decodeExt(data, type, context);
+        }
+        else {
+            // decode() does not fail, returns ExtData instead.
+            return new ExtData(type, data);
+        }
+    }
+}
+
+function isArrayBufferLike(buffer) {
+    return (buffer instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer));
+}
+function ensureUint8Array(buffer) {
+    if (buffer instanceof Uint8Array) {
+        return buffer;
+    }
+    else if (ArrayBuffer.isView(buffer)) {
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    else if (isArrayBufferLike(buffer)) {
+        return new Uint8Array(buffer);
+    }
+    else {
+        // ArrayLike<number>
+        return Uint8Array.from(buffer);
+    }
+}
+
+const DEFAULT_MAX_DEPTH = 100;
+const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+class Encoder {
+    extensionCodec;
+    context;
+    useBigInt64;
+    maxDepth;
+    initialBufferSize;
+    sortKeys;
+    forceFloat32;
+    ignoreUndefined;
+    forceIntegerToFloat;
+    pos;
+    view;
+    bytes;
+    entered = false;
+    constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+        this.context = options?.context; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+        this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+        this.sortKeys = options?.sortKeys ?? false;
+        this.forceFloat32 = options?.forceFloat32 ?? false;
+        this.ignoreUndefined = options?.ignoreUndefined ?? false;
+        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+    }
+    clone() {
+        // Because of slightly special argument `context`,
+        // type assertion is needed.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return new Encoder({
+            extensionCodec: this.extensionCodec,
+            context: this.context,
+            useBigInt64: this.useBigInt64,
+            maxDepth: this.maxDepth,
+            initialBufferSize: this.initialBufferSize,
+            sortKeys: this.sortKeys,
+            forceFloat32: this.forceFloat32,
+            ignoreUndefined: this.ignoreUndefined,
+            forceIntegerToFloat: this.forceIntegerToFloat,
+        });
+    }
+    reinitializeState() {
+        this.pos = 0;
+    }
+    /**
+     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+     *
+     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+     */
+    encodeSharedRef(object) {
+        if (this.entered) {
+            const instance = this.clone();
+            return instance.encodeSharedRef(object);
+        }
+        try {
+            this.entered = true;
+            this.reinitializeState();
+            this.doEncode(object, 1);
+            return this.bytes.subarray(0, this.pos);
+        }
+        finally {
+            this.entered = false;
+        }
+    }
+    /**
+     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+     */
+    encode(object) {
+        if (this.entered) {
+            const instance = this.clone();
+            return instance.encode(object);
+        }
+        try {
+            this.entered = true;
+            this.reinitializeState();
+            this.doEncode(object, 1);
+            return this.bytes.slice(0, this.pos);
+        }
+        finally {
+            this.entered = false;
+        }
+    }
+    doEncode(object, depth) {
+        if (depth > this.maxDepth) {
+            throw new Error(`Too deep objects in depth ${depth}`);
+        }
+        if (object == null) {
+            this.encodeNil();
+        }
+        else if (typeof object === "boolean") {
+            this.encodeBoolean(object);
+        }
+        else if (typeof object === "number") {
+            if (!this.forceIntegerToFloat) {
+                this.encodeNumber(object);
+            }
+            else {
+                this.encodeNumberAsFloat(object);
+            }
+        }
+        else if (typeof object === "string") {
+            this.encodeString(object);
+        }
+        else if (this.useBigInt64 && typeof object === "bigint") {
+            this.encodeBigInt64(object);
+        }
+        else {
+            this.encodeObject(object, depth);
+        }
+    }
+    ensureBufferSizeToWrite(sizeToWrite) {
+        const requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+            this.resizeBuffer(requiredSize * 2);
+        }
+    }
+    resizeBuffer(newSize) {
+        const newBuffer = new ArrayBuffer(newSize);
+        const newBytes = new Uint8Array(newBuffer);
+        const newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+    }
+    encodeNil() {
+        this.writeU8(0xc0);
+    }
+    encodeBoolean(object) {
+        if (object === false) {
+            this.writeU8(0xc2);
+        }
+        else {
+            this.writeU8(0xc3);
+        }
+    }
+    encodeNumber(object) {
+        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+            if (object >= 0) {
+                if (object < 0x80) {
+                    // positive fixint
+                    this.writeU8(object);
+                }
+                else if (object < 0x100) {
+                    // uint 8
+                    this.writeU8(0xcc);
+                    this.writeU8(object);
+                }
+                else if (object < 0x10000) {
+                    // uint 16
+                    this.writeU8(0xcd);
+                    this.writeU16(object);
+                }
+                else if (object < 0x100000000) {
+                    // uint 32
+                    this.writeU8(0xce);
+                    this.writeU32(object);
+                }
+                else if (!this.useBigInt64) {
+                    // uint 64
+                    this.writeU8(0xcf);
+                    this.writeU64(object);
+                }
+                else {
+                    this.encodeNumberAsFloat(object);
+                }
+            }
+            else {
+                if (object >= -32) {
+                    // negative fixint
+                    this.writeU8(0xe0 | (object + 0x20));
+                }
+                else if (object >= -128) {
+                    // int 8
+                    this.writeU8(0xd0);
+                    this.writeI8(object);
+                }
+                else if (object >= -32768) {
+                    // int 16
+                    this.writeU8(0xd1);
+                    this.writeI16(object);
+                }
+                else if (object >= -2147483648) {
+                    // int 32
+                    this.writeU8(0xd2);
+                    this.writeI32(object);
+                }
+                else if (!this.useBigInt64) {
+                    // int 64
+                    this.writeU8(0xd3);
+                    this.writeI64(object);
+                }
+                else {
+                    this.encodeNumberAsFloat(object);
+                }
+            }
+        }
+        else {
+            this.encodeNumberAsFloat(object);
+        }
+    }
+    encodeNumberAsFloat(object) {
+        if (this.forceFloat32) {
+            // float 32
+            this.writeU8(0xca);
+            this.writeF32(object);
+        }
+        else {
+            // float 64
+            this.writeU8(0xcb);
+            this.writeF64(object);
+        }
+    }
+    encodeBigInt64(object) {
+        if (object >= BigInt(0)) {
+            // uint 64
+            this.writeU8(0xcf);
+            this.writeBigUint64(object);
+        }
+        else {
+            // int 64
+            this.writeU8(0xd3);
+            this.writeBigInt64(object);
+        }
+    }
+    writeStringHeader(byteLength) {
+        if (byteLength < 32) {
+            // fixstr
+            this.writeU8(0xa0 + byteLength);
+        }
+        else if (byteLength < 0x100) {
+            // str 8
+            this.writeU8(0xd9);
+            this.writeU8(byteLength);
+        }
+        else if (byteLength < 0x10000) {
+            // str 16
+            this.writeU8(0xda);
+            this.writeU16(byteLength);
+        }
+        else if (byteLength < 0x100000000) {
+            // str 32
+            this.writeU8(0xdb);
+            this.writeU32(byteLength);
+        }
+        else {
+            throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+        }
+    }
+    encodeString(object) {
+        const maxHeaderSize = 1 + 4;
+        const byteLength = utf8Count(object);
+        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+        this.writeStringHeader(byteLength);
+        utf8Encode(object, this.bytes, this.pos);
+        this.pos += byteLength;
+    }
+    encodeObject(object, depth) {
+        // try to encode objects with custom codec first of non-primitives
+        const ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+            this.encodeExtension(ext);
+        }
+        else if (Array.isArray(object)) {
+            this.encodeArray(object, depth);
+        }
+        else if (ArrayBuffer.isView(object)) {
+            this.encodeBinary(object);
+        }
+        else if (typeof object === "object") {
+            this.encodeMap(object, depth);
+        }
+        else {
+            // symbol, function and other special object come here unless extensionCodec handles them.
+            throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+        }
+    }
+    encodeBinary(object) {
+        const size = object.byteLength;
+        if (size < 0x100) {
+            // bin 8
+            this.writeU8(0xc4);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // bin 16
+            this.writeU8(0xc5);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // bin 32
+            this.writeU8(0xc6);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error(`Too large binary: ${size}`);
+        }
+        const bytes = ensureUint8Array(object);
+        this.writeU8a(bytes);
+    }
+    encodeArray(object, depth) {
+        const size = object.length;
+        if (size < 16) {
+            // fixarray
+            this.writeU8(0x90 + size);
+        }
+        else if (size < 0x10000) {
+            // array 16
+            this.writeU8(0xdc);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // array 32
+            this.writeU8(0xdd);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error(`Too large array: ${size}`);
+        }
+        for (const item of object) {
+            this.doEncode(item, depth + 1);
+        }
+    }
+    countWithoutUndefined(object, keys) {
+        let count = 0;
+        for (const key of keys) {
+            if (object[key] !== undefined) {
+                count++;
+            }
+        }
+        return count;
+    }
+    encodeMap(object, depth) {
+        const keys = Object.keys(object);
+        if (this.sortKeys) {
+            keys.sort();
+        }
+        const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        if (size < 16) {
+            // fixmap
+            this.writeU8(0x80 + size);
+        }
+        else if (size < 0x10000) {
+            // map 16
+            this.writeU8(0xde);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // map 32
+            this.writeU8(0xdf);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error(`Too large map object: ${size}`);
+        }
+        for (const key of keys) {
+            const value = object[key];
+            if (!(this.ignoreUndefined && value === undefined)) {
+                this.encodeString(key);
+                this.doEncode(value, depth + 1);
+            }
+        }
+    }
+    encodeExtension(ext) {
+        if (typeof ext.data === "function") {
+            const data = ext.data(this.pos + 6);
+            const size = data.length;
+            if (size >= 0x100000000) {
+                throw new Error(`Too large extension object: ${size}`);
+            }
+            this.writeU8(0xc9);
+            this.writeU32(size);
+            this.writeI8(ext.type);
+            this.writeU8a(data);
+            return;
+        }
+        const size = ext.data.length;
+        if (size === 1) {
+            // fixext 1
+            this.writeU8(0xd4);
+        }
+        else if (size === 2) {
+            // fixext 2
+            this.writeU8(0xd5);
+        }
+        else if (size === 4) {
+            // fixext 4
+            this.writeU8(0xd6);
+        }
+        else if (size === 8) {
+            // fixext 8
+            this.writeU8(0xd7);
+        }
+        else if (size === 16) {
+            // fixext 16
+            this.writeU8(0xd8);
+        }
+        else if (size < 0x100) {
+            // ext 8
+            this.writeU8(0xc7);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // ext 16
+            this.writeU8(0xc8);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // ext 32
+            this.writeU8(0xc9);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error(`Too large extension object: ${size}`);
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+    }
+    writeU8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+    }
+    writeU8a(values) {
+        const size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+    }
+    writeI8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+    }
+    writeU16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+    }
+    writeI16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+    }
+    writeU32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+    }
+    writeI32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+    }
+    writeF32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+    }
+    writeF64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+    }
+    writeU64(value) {
+        this.ensureBufferSizeToWrite(8);
+        setUint64(this.view, this.pos, value);
+        this.pos += 8;
+    }
+    writeI64(value) {
+        this.ensureBufferSizeToWrite(8);
+        setInt64(this.view, this.pos, value);
+        this.pos += 8;
+    }
+    writeBigUint64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigUint64(this.pos, value);
+        this.pos += 8;
+    }
+    writeBigInt64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigInt64(this.pos, value);
+        this.pos += 8;
+    }
+}
+
+/**
+ * It encodes `value` in the MessagePack format and
+ * returns a byte buffer.
+ *
+ * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+ */
+function encode(value, options) {
+    const encoder = new Encoder(options);
+    return encoder.encodeSharedRef(value);
+}
+
+const DEFAULT_MAX_KEY_LENGTH = 16;
+const DEFAULT_MAX_LENGTH_PER_KEY = 16;
+class CachedKeyDecoder {
+    hit = 0;
+    miss = 0;
+    caches;
+    maxKeyLength;
+    maxLengthPerKey;
+    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        // avoid `new Array(N)`, which makes a sparse array,
+        // because a sparse array is typically slower than a non-sparse array.
+        this.caches = [];
+        for (let i = 0; i < this.maxKeyLength; i++) {
+            this.caches.push([]);
+        }
+    }
+    canBeCached(byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+    }
+    find(bytes, inputOffset, byteLength) {
+        const records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (const record of records) {
+            const recordBytes = record.bytes;
+            for (let j = 0; j < byteLength; j++) {
+                if (recordBytes[j] !== bytes[inputOffset + j]) {
+                    continue FIND_CHUNK;
+                }
+            }
+            return record.str;
+        }
+        return null;
+    }
+    store(bytes, value) {
+        const records = this.caches[bytes.length - 1];
+        const record = { bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+            // `records` are full!
+            // Set `record` to an arbitrary position.
+            records[(Math.random() * records.length) | 0] = record;
+        }
+        else {
+            records.push(record);
+        }
+    }
+    decode(bytes, inputOffset, byteLength) {
+        const cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+            this.hit++;
+            return cachedValue;
+        }
+        this.miss++;
+        const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+        // Ensure to copy a slice of bytes because the bytes may be a NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str);
+        return str;
+    }
+}
+
+const EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+new Uint8Array(EMPTY_VIEW.buffer);
+try {
+    // IE11: The spec says it should throw RangeError,
+    // IE11: but in IE11 it throws TypeError.
+    EMPTY_VIEW.getInt8(0);
+}
+catch (e) {
+    if (!(e instanceof RangeError)) {
+        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+    }
+}
+new CachedKeyDecoder();
+
+function encodeMiniProgramShareExtra(value) {
+    assertExtraValue(value);
+    const bytes = encode(value);
+    if (bytes.byteLength > 128)
+        throw new Error('share extra is too large');
+    return btoa(String.fromCharCode(...bytes))
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replaceAll('=', '');
+}
+function assertExtraValue(value, depth = 0, seen = new WeakSet()) {
+    if (depth > 8)
+        throw new Error('extra nesting depth exceeded');
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number') {
+        if (Number.isFinite(value))
+            return;
+        throw new Error('extra number must be finite');
+    }
+    if (typeof value !== 'object')
+        throw new Error('extra value must be JSON-compatible');
+    if (seen.has(value))
+        throw new Error('extra value must not contain cycles');
+    seen.add(value);
+    if (Array.isArray(value)) {
+        if (value.length > 64)
+            throw new Error('extra array is too large');
+        for (const item of value)
+            assertExtraValue(item, depth + 1, seen);
+        seen.delete(value);
+        return;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw new Error('extra object must be a plain object');
+    const values = Object.values(value);
+    if (values.length > 64)
+        throw new Error('extra object has too many fields');
+    for (const item of values)
+        assertExtraValue(item, depth + 1, seen);
+    seen.delete(value);
+}
+
 function isRecord$3(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -3003,11 +4010,11 @@ function readHttpUrl(value, message) {
 function isShareChannel(value) {
     return value === 'wechatSession' || value === 'wechatTimeline' || value === 'qqFriend' || value === 'qzone' || value === 'weibo';
 }
-function createDefaultShareUrl(options) {
+function createDefaultShareUrl(options, method, extra) {
     const identity = options.identity.get();
     const miniProgramId = identity?.miniProgramId.trim();
     if (!miniProgramId)
-        return invalidParams$2('share.showShareMenu url 必须是 HTTP(S) URL');
+        return invalidParams$2(`${method} 缺少有效的小程序分享地址`);
     try {
         const currentUrl = new URL(options.environment.getCurrentHref());
         const shareUrl = new URL('/tools/common_share', currentUrl);
@@ -3018,10 +4025,12 @@ function createDefaultShareUrl(options) {
         const hSrc = currentUrl.searchParams.get('h_src');
         if (hSrc?.trim())
             shareUrl.searchParams.set('h_src', hSrc);
+        if (extra !== undefined)
+            shareUrl.searchParams.set('extra', extra);
         return shareUrl.href;
     }
     catch {
-        return invalidParams$2('share.showShareMenu url 必须是 HTTP(S) URL');
+        return invalidParams$2(`${method} 缺少有效的小程序分享地址`);
     }
 }
 function readShareMenuInput(payload, options) {
@@ -3030,15 +4039,18 @@ function readShareMenuInput(payload, options) {
     const channel = payload.channel;
     if (channel !== undefined && !isShareChannel(channel))
         return invalidParams$2('share.showShareMenu channel 不合法');
+    const extra = readShareExtra(payload.extra, 'share.showShareMenu');
     let url;
     if (typeof payload.url === 'string' && payload.url.trim()) {
+        if (extra !== undefined)
+            return invalidParams$2('share.showShareMenu url 与 extra 不能同时使用');
         url = readHttpUrl(payload.url, 'share.showShareMenu url 必须是 HTTP(S) URL');
     }
     else if (payload.url !== undefined && payload.url !== null && payload.url !== '') {
         return invalidParams$2('share.showShareMenu url 必须是 HTTP(S) URL');
     }
     else {
-        url = createDefaultShareUrl(options);
+        url = createDefaultShareUrl(options, 'share.showShareMenu', extra);
     }
     return {
         title: readRequiredString(payload.title, 'share.showShareMenu title 必须是非空字符串'),
@@ -3048,6 +4060,16 @@ function readShareMenuInput(payload, options) {
         ...(channel === undefined ? {} : { channel }),
     };
 }
+function readShareExtra(value, method) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return encodeMiniProgramShareExtra(value);
+    }
+    catch {
+        return invalidParams$2(`${method} extra 必须是符合限制的 JSON-compatible 数据`);
+    }
+}
 async function normalizePost(result, options) {
     if (!result.invalidMessage)
         return result.post;
@@ -3117,6 +4139,15 @@ async function showShareMenu(payload, options) {
     const post = await normalizePost(postResult, options);
     return waitForHostOperation(() => options.presentation.showShareMenu({ ...input, post }, options.operationContext), options.operationContext.signal);
 }
+async function copyLink(payload, options) {
+    throwIfAborted(options.operationContext.signal);
+    if (payload !== undefined && !isRecord$2(payload))
+        return invalidParams$2('share.copyLink 参数必须是对象');
+    const extra = readShareExtra(payload?.extra, 'share.copyLink');
+    const url = createDefaultShareUrl(options, 'share.copyLink', extra);
+    await waitForHostOperation(() => options.presentation.setClipboard({ text: url }, options.operationContext), options.operationContext.signal);
+    return url;
+}
 async function screenshot(payload, options) {
     throwIfAborted(options.operationContext.signal);
     const input = readScreenshotOptions(payload, options.presentation);
@@ -3171,6 +4202,7 @@ async function restoreScreenshotChrome(presentation, cleanupContext, operationSi
 }
 function createShareCapabilityHandlers(options) {
     return {
+        [SHARE_COPY_LINK_METHOD]: (payload, _context) => copyLink(payload, options),
         [SHARE_SHOW_SHARE_MENU_METHOD]: (payload, _context) => showShareMenu(payload, options),
         [SHARE_SCREENSHOT_METHOD]: (payload, _context) => screenshot(payload, options),
     };
@@ -9019,12 +10051,28 @@ 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';
 
-const DEFAULT_PERMISSION_STATE = {
-    networkRequest: {
+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',
         useOfficialDomain: false,
     },
@@ -9055,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) {
@@ -9133,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;
@@ -9195,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') {
@@ -9220,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);
@@ -9260,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)),
@@ -9275,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));
     }
 }
@@ -9284,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);
@@ -9299,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,
@@ -9338,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),
         },
     };
 }
@@ -9372,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();
@@ -9418,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();
@@ -9475,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'))
@@ -9561,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' });
@@ -9578,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,
@@ -9585,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,
     };
 }
@@ -9611,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');
@@ -9619,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() {
@@ -9639,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);
@@ -9661,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(() => {
@@ -9693,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 = {};
@@ -9752,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) {
@@ -9766,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);
@@ -9780,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);
@@ -9798,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 : '操作失败';