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

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' },
     {
@@ -216,11 +218,18 @@ function readBrowserEnvironment() {
         return { activeElement: null };
     }
 }
-/** 按浏览器消息、用户激活和目标 iframe 焦点生成请求级可信手势快照。 */
-function computeTrustedIframeUserGesture(event, iframe, environment = readBrowserEnvironment()) {
-    return (event.isTrusted === true
-        && environment.userActivation?.isActive === true
-        && environment.activeElement === iframe);
+const USER_GESTURE_TTL_MS = 1000;
+/** 优先使用 User Activation；旧版 WebView 使用带时效的 iframe 焦点回退。 */
+function computeTrustedIframeUserGesture(iframe, environment = readBrowserEnvironment()) {
+    if (environment.userActivation) {
+        return environment.userActivation.isActive === true;
+    }
+    const lastUserInteractionAt = environment.lastUserInteractionAt;
+    const now = environment.now ?? Date.now();
+    return (environment.activeElement === iframe
+        && lastUserInteractionAt !== undefined
+        && now >= lastUserInteractionAt
+        && now - lastUserInteractionAt <= USER_GESTURE_TTL_MS);
 }
 
 const RUNTIME_GATE_PROBE_METHOD = 'runtime.gate.probe';
@@ -238,6 +247,7 @@ class MiniProgramBridgeServer {
         this.onDuplicateHandshake = options.onDuplicateHandshake;
         this.onInternalEvent = options.onInternalEvent;
         this.handleMessage = this.onMessage.bind(this);
+        this.handleUserInteraction = this.onUserInteraction.bind(this);
         this.dispatcher = options.dispatcher;
         this.targetOrigin = options.targetOrigin || '*';
     }
@@ -248,6 +258,9 @@ class MiniProgramBridgeServer {
         }
         this.started = true;
         window.addEventListener('message', this.handleMessage);
+        for (const eventName of ['pointerdown', 'touchend', 'mousedown', 'keydown']) {
+            window.addEventListener(eventName, this.handleUserInteraction, true);
+        }
     }
     /** 设置发送给 iframe 的 targetOrigin。 */
     setTargetOrigin(targetOrigin) {
@@ -263,6 +276,10 @@ class MiniProgramBridgeServer {
             timestamp: Date.now(),
         });
         window.removeEventListener('message', this.handleMessage);
+        for (const eventName of ['pointerdown', 'touchend', 'mousedown', 'keydown']) {
+            window.removeEventListener(eventName, this.handleUserInteraction, true);
+        }
+        this.lastUserInteractionAt = undefined;
     }
     /** 向 iframe 内小程序派发生命周期或业务事件。 */
     postEvent(eventName, payload) {
@@ -297,13 +314,31 @@ class MiniProgramBridgeServer {
             return;
         }
         if (message.type === 'request') {
-            this.handleRequest(message, computeTrustedIframeUserGesture(event, this.iframe));
+            let trustedUserGesture = false;
+            try {
+                trustedUserGesture = computeTrustedIframeUserGesture(this.iframe, {
+                    activeElement: document.activeElement,
+                    userActivation: navigator.userActivation,
+                    lastUserInteractionAt: this.lastUserInteractionAt,
+                    now: Date.now(),
+                });
+            }
+            catch {
+                trustedUserGesture = false;
+            }
+            this.handleRequest(message, trustedUserGesture);
             return;
         }
         if (message.type === 'event' && this.handshaken) {
             this.onInternalEvent?.(message);
         }
     }
+    onUserInteraction(event) {
+        const path = typeof event.composedPath === 'function' ? event.composedPath() : [];
+        if (event.target === this.iframe || path.includes(this.iframe)) {
+            this.lastUserInteractionAt = Date.now();
+        }
+    }
     isTrustedMiniProgramMessage(event) {
         return (event.source === this.iframe.contentWindow &&
             isMiniProgramBridgeMessage(event.data) &&
@@ -412,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'],
@@ -624,6 +660,64 @@ function parseAPIResponse(response, fallbackMessage) {
     return data;
 }
 
+/**
+ * @packageDocumentation
+ * 定义 AccountUserBaseInfo 接口的 Runtime endpoint 契约。
+ */
+/**
+ * AccountUserBaseInfo 原始信封 endpoint。
+ *
+ * @remarks
+ * 供需要区分 `login`、`relogin` 等认证状态的领域服务使用；调用输入仍为 `void`，
+ * wire path 只由本 API contract owner 维护。
+ */
+const accountUserBaseInfoEnvelopeEndpoint = {
+    auth: 'optional',
+    channel: 'api',
+    id: 'heybox.account.user_base_info.envelope.get',
+    method: 'GET',
+    path: '/account/get_user_base_info',
+};
+
+/**
+ * @packageDocumentation
+ * 定义 UserMiniprogramPublicDetail 接口的 Runtime endpoint 契约。
+ */
+/** 用户侧工坊小程序详情 endpoint。 */
+const userMiniprogramPublicDetailEndpoint = {
+    auth: 'optional',
+    channel: 'api',
+    failurePresentation: 'none',
+    id: 'heybox.user_miniprogram.public.detail.get',
+    method: 'GET',
+    path: '/user_miniprogram/public/detail',
+    /**
+     * 把业务输入映射为接口 query。
+     *
+     * @param input - 已由调用方提供的接口输入。
+     */
+    query(input) {
+        return {
+            mini_program_id: input.mini_program_id,
+            ...(input.miniprogram_version ? { miniprogram_version: input.miniprogram_version } : {}),
+            ...(input.preview_token ? { preview_token: input.preview_token } : {}),
+            ...(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 } : {}),
+        };
+    },
+    /**
+     * 保留标准响应信封，由迁移页维持旧 `status` 分支语义。
+     *
+     * @param response - Runtime request pipeline 返回的 transport 响应。
+     * @param _input - 当前 endpoint 输入；解析响应时无需读取。
+     */
+    parse(response, _input) {
+        return parseAPIResponse(response, '工坊小程序详情加载失败');
+    },
+};
+
 function runtimeContextBody(runtimeContext) {
     return { mini_program_id: runtimeContext.miniProgramId };
 }
@@ -964,6 +1058,7 @@ async function requestEndpoint(network, endpoint, input, context) {
 }
 
 const USER_INFO_AUTHORIZATION_SCOPE_SET = new Set(USER_INFO_AUTHORIZATION_SCOPES);
+const AUTHORIZATION_PRESENTATION_DETAILS_TIMEOUT_MS = 1000;
 function createAuthorizationCoordinator(options) {
     const listeners = new Set();
     const localIdentityCache = new Map();
@@ -972,13 +1067,18 @@ function createAuthorizationCoordinator(options) {
     let generation = 0;
     let disposed = false;
     let presentationQueue = Promise.resolve();
+    let activePresentationController;
     const unsubscribeAccount = options.account.onChange((userId) => {
+        invalidateAuthorizationContext();
+        emit('heybox_app_login_change', { isHeyboxAppLoggedIn: Boolean(userId) });
+    });
+    function invalidateAuthorizationContext() {
         generation += 1;
+        activePresentationController?.abort();
         localIdentityCache.clear();
         localIdentityInflight.clear();
         grantedScopes.clear();
-        emit('heybox_app_login_change', { isHeyboxAppLoggedIn: Boolean(userId) });
-    });
+    }
     function emit(name, payload) {
         for (const listener of listeners) {
             try {
@@ -1036,12 +1136,14 @@ function createAuthorizationCoordinator(options) {
         }
         return userId;
     }
-    async function request(endpoint, input) {
+    async function request(endpoint, input, signal = options.operationContext.signal) {
         try {
-            return await requestEndpoint(options.network, endpoint, input, {
+            if (signal.aborted)
+                throw createAbortError$3();
+            return await waitForAbortableOperation(requestEndpoint(options.network, endpoint, input, {
                 credentials: 'heybox-session',
-                signal: options.operationContext.signal,
-            });
+                signal,
+            }), signal);
         }
         catch (error) {
             if (options.operationContext.signal.aborted) {
@@ -1071,7 +1173,19 @@ function createAuthorizationCoordinator(options) {
         }).catch(() => undefined);
     }
     function runPresentation(operation) {
-        const result = presentationQueue.then(operation, operation);
+        const run = async () => {
+            const controller = createLinkedAbortController(options.operationContext.signal);
+            activePresentationController = controller;
+            try {
+                return await operation(controller.signal);
+            }
+            finally {
+                if (activePresentationController === controller)
+                    activePresentationController = undefined;
+                controller.abort();
+            }
+        };
+        const result = presentationQueue.then(run, run);
         presentationQueue = result.then(() => undefined, () => undefined);
         return result;
     }
@@ -1084,14 +1198,17 @@ function createAuthorizationCoordinator(options) {
             await cancelAuthorization(miniProgramId, challengeValue.challenge);
             throw createCapabilityBridgeError('AUTHORIZATION_PRESENTATION_UNAVAILABLE', '授权确认界面不可用');
         }
-        return runPresentation(async () => {
+        return runPresentation(async (presentationSignal) => {
+            await assertAuthorizationContext(expectedUserId, expectedGeneration);
+            const presentationDetails = await loadAuthorizationPresentationDetails(miniProgramId, challengeValue.displayedScopes, presentationSignal);
             await assertAuthorizationContext(expectedUserId, expectedGeneration);
             let decision;
             try {
                 decision = await options.authPresentation.confirmAuthorization({
                     miniProgramId,
                     scopes: challengeValue.displayedScopes,
-                    signal: options.operationContext.signal,
+                    ...presentationDetails,
+                    signal: presentationSignal,
                 });
             }
             catch (error) {
@@ -1115,6 +1232,53 @@ function createAuthorizationCoordinator(options) {
             return selectedScopes;
         });
     }
+    async function loadAuthorizationPresentationDetails(miniProgramId, displayedScopes, presentationSignal) {
+        const detailController = createLinkedAbortController(presentationSignal);
+        const timeout = setTimeout(() => detailController.abort(), AUTHORIZATION_PRESENTATION_DETAILS_TIMEOUT_MS);
+        try {
+            const trustedMiniProgram = normalizeMiniProgramPresentation(options.miniProgramPresentation);
+            const [miniProgram, userProfile] = await Promise.all([
+                trustedMiniProgram ? Promise.resolve(trustedMiniProgram) : loadMiniProgramPresentation(miniProgramId, detailController.signal),
+                displayedScopes.includes('profile') ? loadUserProfilePresentation(detailController.signal) : Promise.resolve(undefined),
+            ]);
+            return {
+                ...(miniProgram ? { miniProgram } : {}),
+                ...(userProfile ? { userProfile } : {}),
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+            detailController.abort();
+        }
+    }
+    async function loadMiniProgramPresentation(miniProgramId, signal) {
+        try {
+            const version = options.identity.get()?.version?.trim();
+            const envelope = await request(userMiniprogramPublicDetailEndpoint, {
+                mini_program_id: miniProgramId,
+                ...(version ? { miniprogram_version: version } : {}),
+            }, signal);
+            const result = readSuccessfulResult$3(envelope, '小程序公开资料');
+            const name = readOptionalPresentationText(result.name);
+            const avatarUrl = readOptionalPresentationText(result.icon_url);
+            return name || avatarUrl ? { ...(name ? { name } : {}), ...(avatarUrl ? { avatarUrl } : {}) } : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async function loadUserProfilePresentation(signal) {
+        try {
+            const envelope = await request(accountUserBaseInfoEnvelopeEndpoint, undefined, signal);
+            const result = readSuccessfulResult$3(envelope, '账号基础信息');
+            const nickname = readOptionalPresentationText(result.display_username);
+            const avatar = readOptionalPresentationText(result.display_avatar);
+            return nickname || avatar ? { ...(nickname ? { nickname } : {}), ...(avatar ? { avatar } : {}) } : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async function login(scopes, trustedUserGesture) {
         const miniProgramId = requireCanonicalMiniProgramId();
         const userId = await requireAuthenticatedUser(trustedUserGesture);
@@ -1231,10 +1395,7 @@ function createAuthorizationCoordinator(options) {
         });
         await assertAuthorizationContext(userId, expectedGeneration);
         readSuccessfulResult$3(envelope, '用户授权撤销');
-        generation += 1;
-        localIdentityCache.clear();
-        localIdentityInflight.clear();
-        grantedScopes.clear();
+        invalidateAuthorizationContext();
         emit('user_info_authorization_change', { identity: 'denied', profile: 'denied' });
         return undefined;
     }
@@ -1251,11 +1412,8 @@ function createAuthorizationCoordinator(options) {
             if (disposed)
                 return;
             disposed = true;
-            generation += 1;
+            invalidateAuthorizationContext();
             unsubscribeAccount();
-            localIdentityCache.clear();
-            localIdentityInflight.clear();
-            grantedScopes.clear();
             listeners.clear();
         },
     };
@@ -1339,6 +1497,46 @@ function validateSelectedScopes(scopes, displayedScopes) {
     }
     return selected;
 }
+function readOptionalPresentationText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeMiniProgramPresentation(value) {
+    const name = readOptionalPresentationText(value?.name);
+    const avatarUrl = readOptionalPresentationText(value?.avatarUrl);
+    return name || avatarUrl ? { ...(name ? { name } : {}), ...(avatarUrl ? { avatarUrl } : {}) } : undefined;
+}
+function createLinkedAbortController(parent) {
+    const controller = new AbortController();
+    if (parent.aborted) {
+        controller.abort(parent.reason);
+    }
+    else {
+        parent.addEventListener('abort', () => controller.abort(parent.reason), { once: true, signal: controller.signal });
+    }
+    return controller;
+}
+function waitForAbortableOperation(operation, signal) {
+    if (signal.aborted)
+        return Promise.reject(createAbortError$3());
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            callback();
+        };
+        const onAbort = () => settle(() => reject(createAbortError$3()));
+        signal.addEventListener('abort', onAbort, { once: true });
+        operation.then((value) => settle(() => resolve(value)), (error) => settle(() => reject(error)));
+    });
+}
+function createAbortError$3() {
+    const error = new Error('The operation was aborted');
+    error.name = 'AbortError';
+    return error;
+}
 function validateScopeArray(value, label) {
     if (!Array.isArray(value) ||
         value.some((scope) => typeof scope !== 'string' || !USER_INFO_AUTHORIZATION_SCOPE_SET.has(scope)) ||
@@ -2686,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);
 }
@@ -2809,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);
@@ -2824,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) {
@@ -2836,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 必须是非空字符串'),
@@ -2854,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;
@@ -2923,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);
@@ -2977,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),
     };
@@ -3267,25 +4493,6 @@ function isBridgeError$1(error) {
     return isCapabilityRecord(error) && typeof error.code === 'string' && typeof error.message === 'string';
 }
 
-/**
- * @packageDocumentation
- * 定义 AccountUserBaseInfo 接口的 Runtime endpoint 契约。
- */
-/**
- * AccountUserBaseInfo 原始信封 endpoint。
- *
- * @remarks
- * 供需要区分 `login`、`relogin` 等认证状态的领域服务使用；调用输入仍为 `void`，
- * wire path 只由本 API contract owner 维护。
- */
-const accountUserBaseInfoEnvelopeEndpoint = {
-    auth: 'optional',
-    channel: 'api',
-    id: 'heybox.account.user_base_info.envelope.get',
-    method: 'GET',
-    path: '/account/get_user_base_info',
-};
-
 /**
  * @packageDocumentation
  * 定义 GameSteamGetGameList 接口的 Runtime endpoint 契约。
@@ -3878,6 +5085,7 @@ function createRuntimeCapabilityModules(options) {
         identity: options.identity,
         operationContext,
         authPresentation: options.authPresentation,
+        miniProgramPresentation: options.miniProgramPresentation,
     });
     let user;
     let cloud;
@@ -4564,6 +5772,7 @@ class MiniProgramRuntimeImpl {
         if (this.isInactive())
             return;
         this.runtimePermissions = configuration.runtimePermissions;
+        this.miniProgramPresentation = configuration.miniProgramPresentation;
         this.locationBasePath = configuration.locationBasePath;
         this.anonymousStorageScope = configuration.anonymousStorageScope ?? this.options.anonymousStorageScope;
         this.allowedHttpOrigins = configuration.allowedHttpOrigins ?? this.options.allowedHttpOrigins;
@@ -4625,6 +5834,7 @@ class MiniProgramRuntimeImpl {
             terminalSignal: this.terminalController.signal,
             eventSink,
             authPresentation: this.options.authPresentation,
+            miniProgramPresentation: this.miniProgramPresentation,
             anonymousStorageScope: this.anonymousStorageScope,
             storageLimits: this.options.storageLimits,
             allowedHttpOrigins: this.allowedHttpOrigins,